diff --git a/Benchmarks/IxVM.lean b/Benchmarks/IxVM.lean
index 39593b6fc..d288aa6ee 100644
--- a/Benchmarks/IxVM.lean
+++ b/Benchmarks/IxVM.lean
@@ -20,7 +20,11 @@ def friParameters : Aiur.FriParameters := {
 }
 
 def main : IO Unit := do
-  let .ok toplevel := IxVM.ixVM
+  -- `ixon_serde_blake3_bench` is a bench-only entrypoint, present only in
+  -- the FULL toplevel (production prunes it), so this prove goes through
+  -- the generic interpreter — the codegen'd kernel mirrors the pruned
+  -- toplevel and has no code (or index) for bench entries.
+  let .ok toplevel := IxVM.ixVMFull
     | throw (IO.userError "Merging failed")
   let .ok compiled := toplevel.compile
     | throw (IO.userError "Compilation failed")
@@ -34,9 +38,7 @@ def main : IO Unit := do
 
   let _ ← bgroup "IxVM benchmarks" { oneShot := true } do
     throughput (.Elements n.toUInt64 "consts")
-    -- IxVM-native prove: routes execution through the codegen'd Rust
-    -- kernel (`execute_generated`) instead of the bytecode interpreter.
     bench "serde/blake3 Nat.add_comm"
-      (aiurSystem.proveIxVM funIdx #[.ofNat n])
+      (aiurSystem.prove funIdx #[.ofNat n])
       ioBuffer
   return
diff --git a/Benchmarks/RecursiveVerifier.lean b/Benchmarks/RecursiveVerifier.lean
index afc51aa02..e3e7c3582 100644
--- a/Benchmarks/RecursiveVerifier.lean
+++ b/Benchmarks/RecursiveVerifier.lean
@@ -136,10 +136,13 @@ def main (args : List String) : IO UInt32 := do
     IO.eprintln "inner proof failed to verify"
     return 1
   -- Proof (advice, channel 0), vk (channel 1), claims (channel 2), plus the
-  -- Blake3-bound vk/claims digests and FRI params as public input.
+  -- Blake3-bound vk/claims digests and FRI params as public input. The
+  -- advice buffer is built natively in Rust from the raw byte blobs
+  -- (`executeMultiStark` / `proveMultiStark`).
   let claimBytes := MultiStark.serializeClaims #[claim]
-  let (pubInput, io) := MultiStark.verifierInput proofBytes facSystem.vkBytes
-    claimBytes recCommitParams innerFri
+  let vkBytes := facSystem.vkBytes
+  let pubInput := MultiStark.verifierPubInput vkBytes claimBytes
+    recCommitParams innerFri
   -- Compile the verifier toplevel and run it over the proof.
   let vTop ← match MultiStark.multiStark with
     | .ok t => pure t
@@ -149,10 +152,17 @@ def main (args : List String) : IO UInt32 := do
     | .error e => IO.eprintln s!"verifier compile failed: {e}"; return 1
   let vIdx := vCompiled.getFuncIdx `verify_multi_stark_proof |>.get!
   IO.println "executing verify_multi_stark_proof…"
+  -- `--use-bytecode`: route through the generic Aiur interpreter instead of
+  -- the codegen'd verifier (same escape hatch as `ix check --use-bytecode`;
+  -- useful for iterating on `Ix/MultiStark/*.lean` without regenerating
+  -- `crates/ixvm-codegen/src/aiur_multi_stark.rs`, and for measuring the
+  -- interpreter ↔ codegen gap).
+  let useBytecode := args.contains "--use-bytecode"
   let e0 ← IO.monoNanosNow
-  match vCompiled.bytecode.execute vIdx pubInput io with
+  match vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes vkBytes
+    claimBytes useBytecode with
   | .error e => IO.eprintln s!"verifier execution REJECTED: {e}"; return 1
-  | .ok (_, _, qc) =>
+  | .ok (_, qc) =>
     let e1 ← IO.monoNanosNow
     let stats := Aiur.computeStats vCompiled qc
     IO.println s!"verifier accepted, execute {secs e0 e1} s"
@@ -178,7 +188,8 @@ def main (args : List String) : IO UInt32 := do
     let vSystem := AiurSystem.build vCompiled.bytecode recCommitParams innerFri
     TracingTexray.resetPeakTreeRss
     let t0 ← IO.monoNanosNow
-    let (vclaim, vproof, _) := vSystem.prove vIdx pubInput io
+    let (vclaim, vproof) := vSystem.proveMultiStark vIdx pubInput proofBytes
+      vkBytes claimBytes
     let nbytes := vproof.toBytes.size  -- force the (lazy, pure) prove to run
     let t1 ← IO.monoNanosNow
     let outerPeak ← TracingTexray.peakTreeRssBytes
diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean
index 3c5b9f183..13e873179 100644
--- a/Benchmarks/Typecheck.lean
+++ b/Benchmarks/Typecheck.lean
@@ -498,17 +498,25 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
           IO.println s!"  [{i + 1}/{ordered.size}] recursively verifying {r.name} …"
           (← IO.getStdout).flush
           let claimBytes := MultiStark.serializeClaims #[claim]
-          let (pubInput, io) := MultiStark.verifierInput proofBytes
-            aiurSystem.vkBytes claimBytes commitParams friParams
+          let vkBytes := aiurSystem.vkBytes
+          let pubInput := MultiStark.verifierPubInput vkBytes claimBytes
+            commitParams friParams
+          -- Native path: the advice buffer is built in Rust from the raw
+          -- byte blobs and execution routes through the codegen'd verifier.
           let (rvRes, rvSec) ← timed fun _ =>
-            vCompiled.bytecode.execute vIdx pubInput io
+            vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes
+              vkBytes claimBytes
           match rvRes with
           | .error e =>
             IO.eprintln s!"  ❌ recursive verifier REJECTED {r.name}'s proof: {e}"
-          | .ok (_, _, qc) =>
+          | .ok (_, qc) =>
             let rvStats := Aiur.computeStats vCompiled qc
             IO.println s!"  {r.name}: recursive={rvSec}s \
               recursive-fft-cost={rvStats.totalFftCost}"
+            -- The per-circuit breakdown names where the verifier's cost
+            -- lives (deserialization vs blake3 vs FRI); texray-gated like
+            -- the other detailed diagnostics.
+            if useTexray then Aiur.printStats rvStats
             let (row, _) := ordered[i]!
             ordered := ordered.set! i
               ({ row with recursiveExecuteSec := some rvSec
@@ -520,8 +528,9 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
             IO.println s!"  [{i + 1}/{ordered.size}] proving the verifier over {r.name} …"
             (← IO.getStdout).flush
             TracingTexray.resetPeakTreeRss
-            let ((rvClaim, rvProof, _), rvProveSec) ← timed fun _ =>
-              vSystem.prove vIdx pubInput io
+            let ((rvClaim, rvProof), rvProveSec) ← timed fun _ =>
+              vSystem.proveMultiStark vIdx pubInput proofBytes vkBytes
+                claimBytes
             let rvPeak ← TracingTexray.peakTreeRssBytes
             let rvProofBytes := Aiur.Proof.toBytes rvProof
             let (rvVerifyRes, rvVerifySec) ← timed fun _ =>
diff --git a/Cargo.lock b/Cargo.lock
index 53739e47e..f078400da 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -52,6 +52,7 @@ version = "0.1.0"
 dependencies = [
  "hashbrown 0.15.5",
  "indexmap",
+ "libc",
  "multi-stark",
  "num-bigint",
  "rayon",
@@ -2075,7 +2076,7 @@ dependencies = [
 [[package]]
 name = "multi-stark"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=2c019220cb43ce946efec6b9caf507f5a6bccd1c#2c019220cb43ce946efec6b9caf507f5a6bccd1c"
+source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=6382036e970ab508e69b2db2b8ae5ad64672e34b#6382036e970ab508e69b2db2b8ae5ad64672e34b"
 dependencies = [
  "bincode",
  "p3-air",
diff --git a/Cargo.toml b/Cargo.toml
index 73fe0ea7b..83c4fcb2a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,10 +47,11 @@ dashmap = "6.1.0"
 hashbrown = "0.15"
 indexmap = "2"
 itertools = "0.14.0"
+libc = "0.2"
 log = "0.4"
 memmap2 = "0.9"
 mimalloc = { version = "0.1", default-features = false }
-multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "2c019220cb43ce946efec6b9caf507f5a6bccd1c" }
+multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "6382036e970ab508e69b2db2b8ae5ad64672e34b" }
 num-bigint = "0.4.6"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean
index 2066a8b43..a7f7dcabf 100644
--- a/Ix/Aiur/Compiler/Check.lean
+++ b/Ix/Aiur/Compiler/Check.lean
@@ -801,6 +801,14 @@ def inferTerm (t : Term) : CheckM Typed.Term := match t with
     let a' ← inferNoEscape a
     let b' ← checkNoEscape b a'.typ
     pure (Typed.Term.unconstrainedBigUintDivMod (.tuple #[a'.typ, a'.typ]) false a' b')
+  | .unconstrainedGToBytes a => do
+    -- The bytes are UNCONSTRAINED advice typed `u8`; the caller must
+    -- range-check them (see `Source.Term.unconstrainedGToBytes`).
+    let a' ← checkNoEscape a .field
+    pure (Typed.Term.unconstrainedGToBytes (.array .u8 8) false a')
+  | .unconstrainedGInverse a => do
+    let a' ← checkNoEscape a .field
+    pure (Typed.Term.unconstrainedGInverse .field false a')
   | .toField a => do
     let a' ← checkNoEscape a .u8
     pure (Typed.Term.toField .field false a')
@@ -981,6 +989,10 @@ def zonkTypedTerm (t : Typed.Term) : CheckM Typed.Term := match t with
       pure (.u8RangeCheck (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
   | .unconstrainedBigUintDivMod τ e a b => do
       pure (.unconstrainedBigUintDivMod (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b))
+  | .unconstrainedGToBytes τ e a => do
+      pure (.unconstrainedGToBytes (← zonkTyp τ) e (← zonkTypedTerm a))
+  | .unconstrainedGInverse τ e a => do
+      pure (.unconstrainedGInverse (← zonkTyp τ) e (← zonkTypedTerm a))
   | .toField τ e a => do pure (.toField (← zonkTyp τ) e (← zonkTypedTerm a))
   | .u8FromFieldUnsafe τ e a => do
       pure (.u8FromFieldUnsafe (← zonkTyp τ) e (← zonkTypedTerm a))
diff --git a/Ix/Aiur/Compiler/Concretize.lean b/Ix/Aiur/Compiler/Concretize.lean
index 389347848..77b735d68 100644
--- a/Ix/Aiur/Compiler/Concretize.lean
+++ b/Ix/Aiur/Compiler/Concretize.lean
@@ -366,6 +366,10 @@ def termToConcrete
   | .unconstrainedBigUintDivMod τ e a b => do
       pure (.unconstrainedBigUintDivMod (← typToConcrete mono τ) e
                                     (← termToConcrete mono a) (← termToConcrete mono b))
+  | .unconstrainedGToBytes τ e a => do
+      pure (.unconstrainedGToBytes (← typToConcrete mono τ) e (← termToConcrete mono a))
+  | .unconstrainedGInverse τ e a => do
+      pure (.unconstrainedGInverse (← typToConcrete mono τ) e (← termToConcrete mono a))
   -- `toField` / `u8FromFieldUnsafe` are erased coercions: `u8` and `field`
   -- share a representation, so we drop the wrapper and keep the inner term.
   | .toField _ _ a | .u8FromFieldUnsafe _ _ a => termToConcrete mono a
@@ -575,6 +579,10 @@ def rewriteTypedTerm (decls : Typed.Decls)
       (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
   | .unconstrainedBigUintDivMod τ e a b => .unconstrainedBigUintDivMod (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
+  | .unconstrainedGToBytes τ e a => .unconstrainedGToBytes (rewriteTyp subst mono τ) e
+      (rewriteTypedTerm decls subst mono a)
+  | .unconstrainedGInverse τ e a => .unconstrainedGInverse (rewriteTyp subst mono τ) e
+      (rewriteTypedTerm decls subst mono a)
   | .toField τ e a => .toField (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono a)
   | .u8FromFieldUnsafe τ e a => .u8FromFieldUnsafe (rewriteTyp subst mono τ) e
@@ -653,6 +661,7 @@ def collectInTypedTerm (seen : Std.HashSet (Global × Array Typ)) :
     collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) a) b
   | .eqZero τ _ a | .store τ _ a | .load τ _ a | .ptrVal τ _ a | .toField τ _ a
   | .u8FromFieldUnsafe τ _ a
+  | .unconstrainedGToBytes τ _ a | .unconstrainedGInverse τ _ a
   | .u8BitDecomposition τ _ a | .u8ShiftLeft τ _ a | .u8ShiftRight τ _ a =>
     collectInTypedTerm (collectInTyp seen τ) a
   | .ioGetInfo τ _ c k =>
@@ -724,6 +733,7 @@ def collectCalls (decls : Typed.Decls)
     collectCalls decls (collectCalls decls seen a) b
   | .eqZero _ _ a | .store _ _ a | .load _ _ a | .ptrVal _ _ a | .toField _ _ a
   | .u8FromFieldUnsafe _ _ a
+  | .unconstrainedGToBytes _ _ a | .unconstrainedGInverse _ _ a
   | .u8BitDecomposition _ _ a | .u8ShiftLeft _ _ a | .u8ShiftRight _ _ a =>
     collectCalls decls seen a
   | .ioGetInfo _ _ c k =>
@@ -839,6 +849,10 @@ def substInTypedTerm (subst : Global → Option Typ) : Typed.Term → Typed.Term
       (substInTypedTerm subst a) (substInTypedTerm subst b)
   | .unconstrainedBigUintDivMod τ e a b => .unconstrainedBigUintDivMod (Typ.instantiate subst τ) e
       (substInTypedTerm subst a) (substInTypedTerm subst b)
+  | .unconstrainedGToBytes τ e a =>
+    .unconstrainedGToBytes (Typ.instantiate subst τ) e (substInTypedTerm subst a)
+  | .unconstrainedGInverse τ e a =>
+    .unconstrainedGInverse (Typ.instantiate subst τ) e (substInTypedTerm subst a)
   | .toField τ e a => .toField (Typ.instantiate subst τ) e (substInTypedTerm subst a)
   | .u8FromFieldUnsafe τ e a =>
     .u8FromFieldUnsafe (Typ.instantiate subst τ) e (substInTypedTerm subst a)
diff --git a/Ix/Aiur/Compiler/Layout.lean b/Ix/Aiur/Compiler/Layout.lean
index 94da06dcc..8e2e4f60f 100644
--- a/Ix/Aiur/Compiler/Layout.lean
+++ b/Ix/Aiur/Compiler/Layout.lean
@@ -207,6 +207,10 @@ def opLayout : Bytecode.Op → LayoutM Unit
   -- No constraint relation, no lookup. Mirrors `IORead` (aux only) — the Rust
   -- `constraints.rs` pushes exactly 2 auxiliaries and emits no relation.
   | .unconstrainedBigUintDivMod .. => do pushDegrees #[1, 1]; bumpAuxiliaries 2
+  -- Unconstrained hints: fresh auxiliary witness columns only, no relation,
+  -- no lookup — same shape as `IORead`. The caller pins the values.
+  | .unconstrainedGToBytes _ => do pushDegrees $ .replicate 8 1; bumpAuxiliaries 8
+  | .unconstrainedGInverse _ => do pushDegree 1; bumpAuxiliaries
   | .debug .. => pure ()
 
 /-- Termination helper for blockLayout's Block/Ctrl traversal. -/
diff --git a/Ix/Aiur/Compiler/Lower.lean b/Ix/Aiur/Compiler/Lower.lean
index bd02acecd..9092cee6b 100644
--- a/Ix/Aiur/Compiler/Lower.lean
+++ b/Ix/Aiur/Compiler/Lower.lean
@@ -333,6 +333,12 @@ def toIndex
     let a ← expectIdx layoutMap bindings a
     let b ← expectIdx layoutMap bindings b
     pushOp (.unconstrainedBigUintDivMod a b) 2
+  | .unconstrainedGToBytes _ _ a => do
+    let a ← expectIdx layoutMap bindings a
+    pushOp (.unconstrainedGToBytes a) 8
+  | .unconstrainedGInverse _ _ a => do
+    let a ← expectIdx layoutMap bindings a
+    pushOp (.unconstrainedGInverse a)
   | .debug _ _ label term ret => do
     let term ← match term with
       | none => pure none
diff --git a/Ix/Aiur/Compiler/Match.lean b/Ix/Aiur/Compiler/Match.lean
index 53c670a0f..f976f9769 100644
--- a/Ix/Aiur/Compiler/Match.lean
+++ b/Ix/Aiur/Compiler/Match.lean
@@ -391,6 +391,8 @@ def typedToSimple : Term → Simple.Term
   | .u32LessThan τ e a b => .u32LessThan τ e (typedToSimple a) (typedToSimple b)
   | .u8RangeCheck τ e a b => .u8RangeCheck τ e (typedToSimple a) (typedToSimple b)
   | .unconstrainedBigUintDivMod τ e a b => .unconstrainedBigUintDivMod τ e (typedToSimple a) (typedToSimple b)
+  | .unconstrainedGToBytes τ e a => .unconstrainedGToBytes τ e (typedToSimple a)
+  | .unconstrainedGInverse τ e a => .unconstrainedGInverse τ e (typedToSimple a)
   | .toField τ e a => .toField τ e (typedToSimple a)
   | .u8FromFieldUnsafe τ e a => .u8FromFieldUnsafe τ e (typedToSimple a)
   | .debug τ e l t r =>
diff --git a/Ix/Aiur/Compiler/Simple.lean b/Ix/Aiur/Compiler/Simple.lean
index 577059947..31b4d1f96 100644
--- a/Ix/Aiur/Compiler/Simple.lean
+++ b/Ix/Aiur/Compiler/Simple.lean
@@ -136,6 +136,12 @@ def simplifyTypedTerm (decls : Source.Decls) : Term → Except CheckError Term
       let a' ← simplifyTypedTerm decls a
       let b' ← simplifyTypedTerm decls b
       pure (.unconstrainedBigUintDivMod τ e a' b')
+  | .unconstrainedGToBytes τ e a => do
+      let a' ← simplifyTypedTerm decls a
+      pure (.unconstrainedGToBytes τ e a')
+  | .unconstrainedGInverse τ e a => do
+      let a' ← simplifyTypedTerm decls a
+      pure (.unconstrainedGInverse τ e a')
   | .toField τ e a => do
       let a' ← simplifyTypedTerm decls a
       pure (.toField τ e a')
diff --git a/Ix/Aiur/Goldilocks.lean b/Ix/Aiur/Goldilocks.lean
index a1e00a5f3..7960f9b38 100644
--- a/Ix/Aiur/Goldilocks.lean
+++ b/Ix/Aiur/Goldilocks.lean
@@ -85,6 +85,27 @@ def G.u8BitDecomposition (a : G) : Fin 8 → G :=
 
 def G.u32LessThan (a b : G) : G := if a.n < b.n then 1 else 0
 
+/-- The 8 little-endian bytes of the canonical `u64` value. Semantic model of
+the `unconstrained_g_to_bytes` hint. -/
+def G.toLeBytes (a : G) : Fin 8 → G :=
+  fun i => G.ofUInt8 (a.val >>> (8 * i.val).toUInt64).toUInt8
+
+/-- Exponentiation by squaring. Fuel-structural (64 bits covers any `n < 2⁶⁴`
+exponent, in particular `p − 2`). -/
+def G.pow (x : G) (n : Nat) : G := go n 64 where
+  go (n fuel : Nat) : G := match fuel with
+    | 0 => 1
+    | fuel + 1 =>
+      if n == 0 then 1
+      else
+        let h := go (n / 2) fuel
+        let sq := h * h
+        if n % 2 == 0 then sq else sq * x
+
+/-- Fermat inverse `x^(p−2)`, with `0 ↦ 0`. Semantic model of the
+`unconstrained_g_inverse` hint. -/
+def G.inverse (x : G) : G := G.pow x (gSize.toNat - 2)
+
 theorem G.one_ne_zero : ¬(1 : G) = (0 : G) := by decide
 
 theorem G.add_comm (a b : G) : a + b = b + a := by
diff --git a/Ix/Aiur/Interpret.lean b/Ix/Aiur/Interpret.lean
index 315b2dd75..c964cae6e 100644
--- a/Ix/Aiur/Interpret.lean
+++ b/Ix/Aiur/Interpret.lean
@@ -417,6 +417,14 @@ partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Valu
       let _ ← interp decls bindings t1
       let _ ← interp decls bindings t2
       throwErr "unconstrainedBigUintDivMod: not implemented in debug interpreter"
+  | .unconstrainedGToBytes t => do
+      match ← interp decls bindings t with
+      | .field g => return .array (Array.ofFn fun i => .field (g.toLeBytes i))
+      | _ => throwErr "unconstrainedGToBytes: expected field value"
+  | .unconstrainedGInverse t => do
+      match ← interp decls bindings t with
+      | .field g => return .field g.inverse
+      | _ => throwErr "unconstrainedGInverse: expected field value"
   -- `toField` / `u8FromFieldUnsafe` are erased coercions: value unchanged.
   | .toField t | .u8FromFieldUnsafe t => interp decls bindings t
   | .u8Lit n => return .field (G.ofNat n)
diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index d7ad59013..5f05b393e 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -205,6 +205,8 @@ syntax "u8_less_than" "(" aiur_trm ", " aiur_trm ")"                        : ai
 syntax "u32_less_than" "(" aiur_trm ", " aiur_trm ")"                       : aiur_trm
 syntax "u8_range_check" "(" aiur_trm ", " aiur_trm ")"                      : aiur_trm
 syntax "unconstrained_big_uint_div_mod" "(" aiur_trm ", " aiur_trm ")"           : aiur_trm
+syntax "unconstrained_g_to_bytes" "(" aiur_trm ")"                          : aiur_trm
+syntax "unconstrained_g_inverse" "(" aiur_trm ")"                           : aiur_trm
 syntax "to_field" "(" aiur_trm ")"                                          : aiur_trm
 syntax "u8_from_field_unsafe" "(" aiur_trm ")"                              : aiur_trm
 syntax:max num "u8"                                                         : aiur_trm
@@ -351,6 +353,10 @@ partial def elabTrm : ElabStxCat `aiur_trm
     mkAppM ``Source.Term.u8RangeCheck #[← elabTrm i, ← elabTrm j]
   | `(aiur_trm| unconstrained_big_uint_div_mod($a:aiur_trm, $b:aiur_trm)) => do
     mkAppM ``Source.Term.unconstrainedBigUintDivMod #[← elabTrm a, ← elabTrm b]
+  | `(aiur_trm| unconstrained_g_to_bytes($a:aiur_trm)) => do
+    mkAppM ``Source.Term.unconstrainedGToBytes #[← elabTrm a]
+  | `(aiur_trm| unconstrained_g_inverse($a:aiur_trm)) => do
+    mkAppM ``Source.Term.unconstrainedGInverse #[← elabTrm a]
   | `(aiur_trm| to_field($a:aiur_trm)) => do
     mkAppM ``Source.Term.toField #[← elabTrm a]
   | `(aiur_trm| u8_from_field_unsafe($a:aiur_trm)) => do
@@ -579,6 +585,12 @@ where
       let a ← replaceToken old new a
       let b ← replaceToken old new b
       `(aiur_trm| unconstrained_big_uint_div_mod($a, $b))
+    | `(aiur_trm| unconstrained_g_to_bytes($a:aiur_trm)) => do
+      let a ← replaceToken old new a
+      `(aiur_trm| unconstrained_g_to_bytes($a))
+    | `(aiur_trm| unconstrained_g_inverse($a:aiur_trm)) => do
+      let a ← replaceToken old new a
+      `(aiur_trm| unconstrained_g_inverse($a))
     | `(aiur_trm| to_field($a:aiur_trm)) => do
       let a ← replaceToken old new a
       `(aiur_trm| to_field($a))
diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean
index b59e3c2dd..376ec09f6 100644
--- a/Ix/Aiur/Protocol.lean
+++ b/Ix/Aiur/Protocol.lean
@@ -96,6 +96,29 @@ def proveIxVM (system : @& AiurSystem)
   let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅
   (claim, proof, ⟨ioData, ioMap⟩)
 
+@[extern "rs_aiur_multi_stark_prove"]
+private opaque proveMultiStark' : @& AiurSystem →
+  @& Bytecode.FunIdx → @& Array G →
+  (proofBytes : @& ByteArray) → (vkBytes : @& ByteArray) →
+  (claimBytes : @& ByteArray) → Bool →
+    Array G × Proof
+
+/-- Prove the MultiStark recursive verifier over raw proof/vk/claims
+    byte blobs. The IO advice buffer is built natively in Rust (see
+    `Bytecode.Toplevel.executeMultiStark`); the execute step inside
+    the prove routes through the codegen'd verifier
+    (`crates/ixvm-codegen/src/aiur_multi_stark.rs`) unless
+    `useBytecode` is set. Only valid when `system` was built from the
+    production `MultiStark.multiStark` bytecode. Returns the claim
+    (`#[functionChannel, funIdx] ++ pubInput ++ output`) and the
+    `Proof`; the final buffer is not returned. -/
+def proveMultiStark (system : @& AiurSystem)
+  (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G)
+  (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) :
+    Array G × Proof :=
+  proveMultiStark' system funIdx pubInput proofBytes vkBytes claimBytes
+    useBytecode
+
 @[extern "rs_aiur_system_prove_addr_with_env"]
 private opaque proveAddrWithEnv' : @& AiurSystem →
   @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray →
diff --git a/Ix/Aiur/Semantics/BytecodeEval.lean b/Ix/Aiur/Semantics/BytecodeEval.lean
index 83b0ba576..db275e1a4 100644
--- a/Ix/Aiur/Semantics/BytecodeEval.lean
+++ b/Ix/Aiur/Semantics/BytecodeEval.lean
@@ -303,6 +303,12 @@ def evalOp (t : Bytecode.Toplevel) (fuel : Nat) (op : Op) (st : EvalState) :
     -- an explicit error rather than silently producing wrong values.
     let _ ← readIdx st a; let _ ← readIdx st b
     .error .unconstrainedBigUintDivModUnsupported
+  | .unconstrainedGToBytes idx => do
+    let g ← readIdx st idx
+    pure (appendMap st (Array.ofFn g.toLeBytes))
+  | .unconstrainedGInverse idx => do
+    let g ← readIdx st idx
+    pure (pushMap st g.inverse)
   | .debug _ _ => .ok st
 termination_by (fuel, sizeOf op, 0)
 decreasing_by all_goals first | decreasing_tactic | omega
diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean
index 690e90392..cbe62fff4 100644
--- a/Ix/Aiur/Semantics/BytecodeFfi.lean
+++ b/Ix/Aiur/Semantics/BytecodeFfi.lean
@@ -157,6 +157,35 @@ def executeIxVM (toplevel : @& Bytecode.Toplevel)
     let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits }
     .ok (output, ⟨ioData, ioMap⟩, queryCounts)
 
+@[extern "rs_aiur_multi_stark_execute"]
+private opaque executeMultiStark' : @& Bytecode.Toplevel →
+  @& Bytecode.FunIdx → @& Array G →
+  (proofBytes : @& ByteArray) → (vkBytes : @& ByteArray) →
+  (claimBytes : @& ByteArray) → Bool →
+    Except String (Array G × Array (Nat × Nat))
+
+/-- MultiStark-native execution of `verify_multi_stark_proof`: the IO
+    advice buffer (channel 0 = proof, 1 = vk, 2 = claims, key `[0]`
+    each) is built natively in Rust from the raw byte blobs — no
+    per-byte boxing into Lean `G`s, no buffer marshalling across FFI.
+    `useBytecode` selects the generic Aiur bytecode interpreter over
+    the codegen'd verifier (`crates/ixvm-codegen/src/aiur_multi_stark.rs`);
+    as with `executeIxVM`, the codegen'd path is only valid when
+    `toplevel` is the production `MultiStark.multiStark` bytecode —
+    other toplevels (e.g. `multiStarkTests`) must pass
+    `useBytecode := true`. Returns the output and per-circuit query
+    counts; the final buffer is not returned (the verifier only reads
+    its advice). -/
+def executeMultiStark (toplevel : @& Bytecode.Toplevel)
+  (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G)
+  (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) :
+    Except String (Array G × Array QueryCount) :=
+  match executeMultiStark' toplevel funIdx pubInput proofBytes vkBytes
+    claimBytes useBytecode with
+  | .error e => .error e
+  | .ok (output, queryCounts) =>
+    .ok (output, queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits })
+
 -- (EnvHandle opaque type + constructors live above `namespace
 -- Bytecode.Toplevel`; see `Aiur.EnvHandle`. The with-env FFI
 -- declarations below reference `EnvHandle` and `Bytecode.Toplevel`
diff --git a/Ix/Aiur/Semantics/SourceEval.lean b/Ix/Aiur/Semantics/SourceEval.lean
index 34f61ccca..0f5b72ea0 100644
--- a/Ix/Aiur/Semantics/SourceEval.lean
+++ b/Ix/Aiur/Semantics/SourceEval.lean
@@ -457,6 +457,21 @@ def interp (decls : Decls) (fuel : Nat) (bindings : Bindings)
         match interp decls fuel bindings t2 st1 with
         | .error e => .error e
         | .ok (_, _) => .error (.typeMismatch "unconstrainedBigUintDivMod")
+  | .unconstrainedGToBytes t =>
+      match interp decls fuel bindings t st with
+      | .error e => .error e
+      | .ok (v, st') =>
+        match v with
+        | .field g =>
+          .ok (.array (Array.ofFn fun i => .field (g.toLeBytes i)), st')
+        | _ => .error (.typeMismatch "unconstrainedGToBytes")
+  | .unconstrainedGInverse t =>
+      match interp decls fuel bindings t st with
+      | .error e => .error e
+      | .ok (v, st') =>
+        match v with
+        | .field g => .ok (.field g.inverse, st')
+        | _ => .error (.typeMismatch "unconstrainedGInverse")
   -- `toField` / `u8FromFieldUnsafe` are erased coercions: value unchanged.
   | .toField t | .u8FromFieldUnsafe t => interp decls fuel bindings t st
   | .u8Lit n => .ok (.field (G.ofNat n), st)
diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean
index 9de3ffe3c..992233145 100644
--- a/Ix/Aiur/Stages/Bytecode.lean
+++ b/Ix/Aiur/Stages/Bytecode.lean
@@ -56,6 +56,15 @@ inductive Op
   and `0 ≤ r < b` (when `b > 0`). No constraint relation emitted; caller
   must verify in constrained code. -/
   | unconstrainedBigUintDivMod : ValIdx → ValIdx → Op
+  /-- Unconstrained hint: the 8 LE bytes of a field element's canonical `u64`
+  value. 8 fresh auxiliary values, no constraint relation, no lookup; the
+  caller must range-check, recompose-assert, and canonicality-assert.
+  Appended last so the existing FFI tags don't shift (tag 29). -/
+  | unconstrainedGToBytes : ValIdx → Op
+  /-- Unconstrained hint: the field inverse of a value (`0 ↦ 0`). One fresh
+  auxiliary value, no constraint relation; the caller must pin it via
+  multiply-and-assert. Appended last (tag 30). -/
+  | unconstrainedGInverse : ValIdx → Op
   deriving Repr, BEq, Hashable
 
 mutual
diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean
index ccab88b75..dca4c3e3f 100644
--- a/Ix/Aiur/Stages/Codegen.lean
+++ b/Ix/Aiur/Stages/Codegen.lean
@@ -352,6 +352,8 @@ def Op.outputCount : Op → Nat
   | .u32LessThan _ _ => 1
   | .u8RangeCheck _ _ => 0
   | .unconstrainedBigUintDivMod _ _ => 2
+  | .unconstrainedGToBytes _ => 8
+  | .unconstrainedGInverse _ => 1
   | .debug _ _ => 0
 
 private def emitConst (out : Nat) (c : Aiur.G) : Array RustStmt :=
@@ -635,6 +637,22 @@ private def emitUncBigUintDivMod (out : Nat) (a b : ValIdx) : Array RustStmt :=
     declVal (out + 1) (.field (.var "__bu_qr") "1")
   ]
 
+/-- `Op::UnconstrainedGToBytes`: 8 outputs — the LE bytes of the input's
+    canonical `u64` value, as unconstrained advice. -/
+private def emitUncGToBytes (out : Nat) (a : ValIdx) : Array RustStmt := Id.run do
+  let mut stmts : Array RustStmt :=
+    #[.letStmt false "__gb" (some "[u8; 8]")
+      (.lit s!"__v_{a}.as_canonical_u64().to_le_bytes()")]
+  for i in [0 : 8] do
+    stmts := stmts.push (declVal (out + i) (.lit s!"G::from_u8(__gb[{i}])"))
+  stmts
+
+/-- `Op::UnconstrainedGInverse`: 1 output — the field inverse (`0 ↦ 0`), as
+    unconstrained advice. Calls the shared `g_inverse_value` helper so the
+    interpreter and codegen produce identical values. -/
+private def emitUncGInverse (out : Nat) (a : ValIdx) : Array RustStmt :=
+  #[declVal out (.lit s!"g_inverse_value(__v_{a})")]
+
 /-- `Op::Debug`: 0 outputs; println side effect, mirroring the bytecode
     interpreter's `Op::Debug` arm (crates/aiur/src/execute.rs). Production
     kernels contain no `dbg!`, so this emits nothing there; when probing
@@ -683,6 +701,8 @@ def emitOp (out : Nat) (op : Op) : Array RustStmt :=
   | .u32LessThan a b => emitU32LessThan out a b
   | .u8RangeCheck i j => emitU8RangeCheck i j
   | .unconstrainedBigUintDivMod a b => emitUncBigUintDivMod out a b
+  | .unconstrainedGToBytes a => emitUncGToBytes out a
+  | .unconstrainedGInverse a => emitUncGInverse out a
   | .debug label args => emitDebug label args
 
 /-! ## Ctrl emission -/
@@ -935,6 +955,7 @@ def optionalExecuteUses : Array (String × String) := #[
   ("bytes2_chain_rotr7_value", "bytes2_chain_rotr7_value"),
   ("bytes2_chain_rotr4_value", "bytes2_chain_rotr4_value"),
   ("unconstrained_big_uint_div_mod_helper", "unconstrained_big_uint_div_mod_helper"),
+  ("g_inverse_value", "g_inverse_value"),
   ("CodegenBytes1 as Bytes1", "Bytes1::"),
   ("CodegenBytes2 as Bytes2", "Bytes2::")
 ]
diff --git a/Ix/Aiur/Stages/Concrete.lean b/Ix/Aiur/Stages/Concrete.lean
index 1592509b9..4dc85fb95 100644
--- a/Ix/Aiur/Stages/Concrete.lean
+++ b/Ix/Aiur/Stages/Concrete.lean
@@ -88,6 +88,8 @@ inductive Term : Type where
   | u8ChainRotr4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
+  | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
   | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term
   deriving Repr, Inhabited
 
@@ -107,6 +109,7 @@ def Term.typ : Term → Typ
   | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _
   | .u8ChainRotr7 t _ _ _ | .u8ChainRotr4 t _ _ _ | .u8RangeCheck t _ _ _
   | .unconstrainedBigUintDivMod t _ _ _
+  | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _
   | .debug t _ _ _ _ => t
 
 /-- Get the escapes flag of a Concrete.Term. -/
@@ -125,6 +128,7 @@ def Term.escapes : Term → Bool
   | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _
   | .u8ChainRotr7 _ e _ _ | .u8ChainRotr4 _ e _ _ | .u8RangeCheck _ e _ _
   | .unconstrainedBigUintDivMod _ e _ _
+  | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _
   | .debug _ e _ _ _ => e
 
 structure Constructor where
diff --git a/Ix/Aiur/Stages/Simple.lean b/Ix/Aiur/Stages/Simple.lean
index 20d622d82..207f71a8f 100644
--- a/Ix/Aiur/Stages/Simple.lean
+++ b/Ix/Aiur/Stages/Simple.lean
@@ -84,6 +84,8 @@ inductive Term : Type where
   | u8ChainRotr4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
+  | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
   | toField (typ : Typ) (escapes : Bool) (a : Term) : Term
   | u8FromFieldUnsafe (typ : Typ) (escapes : Bool) (a : Term) : Term
   | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term
@@ -104,6 +106,7 @@ def Term.typ : Term → Typ
   | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _
   | .u8ChainRotr7 t _ _ _ | .u8ChainRotr4 t _ _ _ | .u8RangeCheck t _ _ _
   | .unconstrainedBigUintDivMod t _ _ _
+  | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _
   | .toField t _ _ | .u8FromFieldUnsafe t _ _
   | .debug t _ _ _ _ => t
 
@@ -122,6 +125,7 @@ def Term.escapes : Term → Bool
   | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _
   | .u8ChainRotr7 _ e _ _ | .u8ChainRotr4 _ e _ _ | .u8RangeCheck _ e _ _
   | .unconstrainedBigUintDivMod _ e _ _
+  | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _
   | .toField _ e _ | .u8FromFieldUnsafe _ e _
   | .debug _ e _ _ _ => e
 
diff --git a/Ix/Aiur/Stages/Source.lean b/Ix/Aiur/Stages/Source.lean
index cbc8ca4fe..d55316e32 100644
--- a/Ix/Aiur/Stages/Source.lean
+++ b/Ix/Aiur/Stages/Source.lean
@@ -439,6 +439,18 @@ inductive Term
   div_rem; no constraints generated and no per-step memo growth. The
   caller must verify `q*b + r == a` and `r < b` in constrained code. -/
   | unconstrainedBigUintDivMod : (a : Term) → (b : Term) → Term
+  /-- Unconstrained hint: the 8 little-endian bytes of a field element's
+  canonical `u64` value, as a `[U8; 8]`. Computed natively by the Aiur
+  runtime; no constraints generated — the bytes are advice. The caller must
+  range-check each byte, assert they recompose to the input
+  (`Σ bᵢ·256ⁱ == x`), and assert canonicality (`< p`) in constrained code;
+  together these pin the unique canonical decomposition. -/
+  | unconstrainedGToBytes : Term → Term
+  /-- Unconstrained hint: the field inverse of a field element (`0 ↦ 0`).
+  Computed natively by the Aiur runtime; no constraints generated — the
+  caller must pin it, e.g. via `t = x·i − 1; assert x·t == 0;
+  assert i·t == 0` (forces `i = x⁻¹` when `x ≠ 0` and `i = 0` otherwise). -/
+  | unconstrainedGInverse : Term → Term
   /-- A `U8` literal in `[0, 256)`. Lowered to a plain field constant of type
   `u8` (no range-check lookup, since the value is statically in range). -/
   | u8Lit : Nat → Term
@@ -677,6 +689,8 @@ def Term.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
   | .u8RangeCheck a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8RangeCheck a' b')
   | .toField a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .toField a')
   | .u8FromFieldUnsafe a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8FromFieldUnsafe a')
+  | .unconstrainedGToBytes a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGToBytes a')
+  | .unconstrainedGInverse a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .unconstrainedGInverse a')
   | .debug s o a =>
     let (cnt, o') := match o with
       | none => (cnt, none)
@@ -726,7 +740,8 @@ def Term.inlineCallSites : Term → List (Global × Nat)
   | .ioRead a b _ => a.inlineCallSites ++ b.inlineCallSites
   | .ret a | .eqZero a | .proj a _ | .get a _ | .slice a _ _ | .store a | .load a
   | .ptrVal a | .ann _ a | .u8BitDecomposition a | .u8ShiftLeft a | .u8ShiftRight a
-  | .toField a | .u8FromFieldUnsafe a => a.inlineCallSites
+  | .toField a | .u8FromFieldUnsafe a
+  | .unconstrainedGToBytes a | .unconstrainedGInverse a => a.inlineCallSites
   | .debug _ o a => (match o with | none => [] | some x => x.inlineCallSites) ++ a.inlineCallSites
 termination_by t => sizeOf t
 decreasing_by
@@ -842,6 +857,8 @@ def Term.expandOnce (done : Std.HashMap Global (List Local × Term)) (cnt : Nat)
   | .u8RangeCheck a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8RangeCheck a' b')
   | .toField a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .toField a')
   | .u8FromFieldUnsafe a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8FromFieldUnsafe a')
+  | .unconstrainedGToBytes a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGToBytes a')
+  | .unconstrainedGInverse a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .unconstrainedGInverse a')
   | .debug s o a =>
     let (cnt, o') := match o with
       | none => (cnt, none)
@@ -939,6 +956,8 @@ def Term.hoistLets : Term → Term :=
   | .u8ShiftRight a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8ShiftRight c)
   | .toField a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.toField c)
   | .u8FromFieldUnsafe a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8FromFieldUnsafe c)
+  | .unconstrainedGToBytes a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.unconstrainedGToBytes c)
+  | .unconstrainedGInverse a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.unconstrainedGInverse c)
   | .u8Xor a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
                   match cs with | [a, b] => Term.wrapLets fs (.u8Xor a b) | _ => t
   | .u8Add a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
@@ -1035,6 +1054,71 @@ def Toplevel.inlineCalls (t : Toplevel) : Except String Toplevel := do
     | some (_, body) => { f with body := body.hoistLets }
   pure { t with functions }
 
+/-- Every `Global` referenced by a term: function calls and constructor
+applications via `.app`, bare references via `.ref` (constants, nullary
+constructors), plus constructor names inside `let`/`match` patterns.
+Non-function references never match a function name, so callers can filter
+against the function table. -/
+partial def Term.collectGlobals (acc : Std.HashSet Global) : Term → Std.HashSet Global
+  | .unit | .var _ | .field _ | .u8Lit _ => acc
+  | .ref g => acc.insert g
+  | .tuple ts | .array ts => ts.foldl Term.collectGlobals acc
+  | .ret t | .eqZero t | .proj t _ | .get t _ | .slice t _ _ | .store t
+  | .load t | .ptrVal t | .ann _ t | .u8BitDecomposition t | .u8ShiftLeft t
+  | .u8ShiftRight t | .unconstrainedGToBytes t | .unconstrainedGInverse t
+  | .toField t | .u8FromFieldUnsafe t => t.collectGlobals acc
+  | .let p v b => b.collectGlobals (v.collectGlobals (patternGlobals acc p))
+  | .match s bs =>
+    bs.foldl (fun a (p, b) => b.collectGlobals (patternGlobals a p))
+      (s.collectGlobals acc)
+  | .app g args _ => args.foldl (fun a t => t.collectGlobals a) (acc.insert g)
+  | .add a b | .sub a b | .mul a b | .u8Xor a b | .u8Add a b
+  | .u8Mul a b | .u8Sub a b | .u8And a b | .u8Or a b | .u8LessThan a b
+  | .u32LessThan a b | .u8ChainRotr7 a b | .u8ChainRotr4 a b
+  | .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 =>
+    r.collectGlobals (b.collectGlobals (a.collectGlobals acc))
+  | .ioSetInfo c k i l r =>
+    r.collectGlobals (l.collectGlobals (i.collectGlobals
+      (k.collectGlobals (c.collectGlobals acc))))
+  | .ioRead c i _ => i.collectGlobals (c.collectGlobals acc)
+  | .debug _ t r =>
+    r.collectGlobals (match t with | none => acc | some t => t.collectGlobals acc)
+where
+  patternGlobals (acc : Std.HashSet Global) : Pattern → Std.HashSet Global
+    | .var _ | .wildcard | .field _ => acc
+    | .ref g ps => ps.foldl patternGlobals (acc.insert g)
+    | .tuple ps | .array ps => ps.foldl patternGlobals acc
+    | .or a b => patternGlobals (patternGlobals acc a) b
+    | .pointer p => patternGlobals acc p
+
+/-- Keep only the functions reachable from `roots` (entry-point names).
+Data types and type aliases are kept wholesale — only functions become
+circuits, so pruning functions is what shrinks the committed system (every
+compiled function is a committed matrix whose openings pad every proof,
+used or not). What gets dropped: `pub` entry points other than the roots
+(test/bench harness entries) and any function only they reach. Relative
+function order is preserved, so surviving indices stay deterministic. -/
+partial def Toplevel.prune (toplevel : Toplevel) (roots : List Lean.Name) : Toplevel :=
+  let byName : Std.HashMap Global Function :=
+    toplevel.functions.foldl (fun a f => a.insert f.name f) ∅
+  let rootGs := toplevel.functions.filterMap fun f =>
+    if roots.contains f.name.toName then some f.name else none
+  let rec go (todo : List Global) (seen : Std.HashSet Global) : Std.HashSet Global :=
+    match todo with
+    | [] => seen
+    | g :: rest =>
+      if seen.contains g then go rest seen
+      else match byName.get? g with
+        | none => go rest seen  -- constructor / datatype / alias reference
+        | some f =>
+          let refs := f.body.collectGlobals ∅
+          go (refs.toList ++ rest) (seen.insert g)
+  let keep := go rootGs.toList ∅
+  { toplevel with functions := toplevel.functions.filter (keep.contains ·.name) }
+
 inductive Declaration
   | function : Function → Declaration
   | dataType : DataType → Declaration
diff --git a/Ix/Aiur/Stages/Typed.lean b/Ix/Aiur/Stages/Typed.lean
index 71e40a9c9..1fa46bc4d 100644
--- a/Ix/Aiur/Stages/Typed.lean
+++ b/Ix/Aiur/Stages/Typed.lean
@@ -60,6 +60,8 @@ inductive Term : Type where
   | u8ChainRotr4 (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | u8RangeCheck (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
   | unconstrainedBigUintDivMod (typ : Typ) (escapes : Bool) (a : Term) (b : Term) : Term
+  | unconstrainedGToBytes (typ : Typ) (escapes : Bool) (a : Term) : Term
+  | unconstrainedGInverse (typ : Typ) (escapes : Bool) (a : Term) : Term
   | toField (typ : Typ) (escapes : Bool) (a : Term) : Term
   | u8FromFieldUnsafe (typ : Typ) (escapes : Bool) (a : Term) : Term
   | debug (typ : Typ) (escapes : Bool) (label : String) (t : Option Term) (r : Term) : Term
@@ -80,6 +82,7 @@ def Term.typ : Term → Typ
   | .u8And t _ _ _ | .u8Or t _ _ _ | .u8LessThan t _ _ _ | .u32LessThan t _ _ _
   | .u8ChainRotr7 t _ _ _ | .u8ChainRotr4 t _ _ _ | .u8RangeCheck t _ _ _
   | .unconstrainedBigUintDivMod t _ _ _
+  | .unconstrainedGToBytes t _ _ | .unconstrainedGInverse t _ _
   | .toField t _ _ | .u8FromFieldUnsafe t _ _
   | .debug t _ _ _ _ => t
 
@@ -98,6 +101,7 @@ def Term.escapes : Term → Bool
   | .u8And _ e _ _ | .u8Or _ e _ _ | .u8LessThan _ e _ _ | .u32LessThan _ e _ _
   | .u8ChainRotr7 _ e _ _ | .u8ChainRotr4 _ e _ _ | .u8RangeCheck _ e _ _
   | .unconstrainedBigUintDivMod _ e _ _
+  | .unconstrainedGToBytes _ e _ | .unconstrainedGInverse _ e _
   | .toField _ e _ | .u8FromFieldUnsafe _ e _
   | .debug _ e _ _ _ => e
 
diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean
index da5cecf98..783645b2c 100644
--- a/Ix/Cli/CodegenCmd.lean
+++ b/Ix/Cli/CodegenCmd.lean
@@ -1,13 +1,17 @@
 /-
-  `ix codegen`: write the IxVM kernel as a Rust source file via the
-  Bytecode → Rust codegen pass.
+  `ix codegen`: write the IxVM kernel and the MultiStark recursive
+  verifier as Rust source files via the Bytecode → Rust codegen pass.
 
-  Output path is fixed at compile time: `crates/ixvm-codegen/src/aiur_ixvm.rs`.
-  The generated file is the single destination; no flag overrides.
+  Output paths are fixed at compile time:
+  - `crates/ixvm-codegen/src/aiur_ixvm.rs` (the IxVM kernel)
+  - `crates/ixvm-codegen/src/aiur_multi_stark.rs` (the recursive verifier)
+  The generated files are the single destinations; no flag overrides.
 
-  Output: a Rust module body containing one `fn aiur_fn_N(...)` per
-  Aiur kernel function, plus per-fn `IN_N` / `OUT_N` / `INPUT_SIZE_N`
-  size constants and the dispatch entry `execute_generated`.
+  Output per target: a Rust module body containing one `fn aiur_fn_N(...)`
+  per Aiur function, plus per-fn `IN_N` / `OUT_N` / `INPUT_SIZE_N`
+  size constants and the dispatch entry `execute_generated`. The two
+  files never collide — each is its own Rust module, and every
+  generated item is module-scoped.
 
   Before integrating into the build pipeline:
   1. Generate code for a single small Aiur fn (e.g. `klimbs_add`).
@@ -25,6 +29,7 @@ public import Cli
 public import Ix.Aiur.Compiler
 public import Ix.Aiur.Stages.Codegen
 public import Ix.IxVM
+public import Ix.MultiStark
 
 public section
 
@@ -32,53 +37,72 @@ namespace Ix.Cli.CodegenCmd
 
 open Aiur
 
-/-- Fixed destination — compile-time constant, no CLI override. -/
-def codegenOutPath : String := "crates/ixvm-codegen/src/aiur_ixvm.rs"
+/-- One codegen target: a human label, the Aiur toplevel to compile, and the
+    fixed destination path (compile-time constant, no CLI override). -/
+structure Target where
+  label : String
+  source : Except Aiur.Global Aiur.Source.Toplevel
+  outPath : String
 
-def runCodegenCmd (p : Cli.Parsed) : IO UInt32 := do
-  let checkOnly := p.hasFlag "check"
-  -- Compile the IxVM source to bytecode.
-  let src ← match IxVM.ixVM with
+def targets : List Target := [
+  { label := "ixvm", source := IxVM.ixVM,
+    outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs" },
+  { label := "multi-stark", source := MultiStark.multiStark,
+    outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs" }
+]
+
+/-- Emit one target. In `--check` mode, compares against the on-disk file
+    without writing; otherwise writes. Returns `false` on any failure
+    (source/compile error, missing or stale file in check mode). -/
+def emitTarget (checkOnly : Bool) (t : Target) : IO Bool := do
+  let src ← match t.source with
     | .ok src => pure src
-    | .error e => IO.eprintln s!"IxVM source error: {repr e}"; return 1
+    | .error e => IO.eprintln s!"{t.label} source error: {repr e}"; return false
   let compiled ← match src.compile with
     | .ok c => pure c
-    | .error e => IO.eprintln s!"Aiur compile error: {e}"; return 1
+    | .error e => IO.eprintln s!"{t.label} Aiur compile error: {e}"; return false
   let rustSource := Aiur.Codegen.emit compiled.bytecode
   if checkOnly then
     -- CI mode: compare emitted source against the on-disk file.
-    -- Exit 0 if identical, 1 otherwise. Does not write.
+    -- Does not write.
     let existing ← try
-      pure (some (← IO.FS.readFile codegenOutPath))
+      pure (some (← IO.FS.readFile t.outPath))
     catch _ => pure none
     match existing with
     | none =>
-      IO.eprintln s!"[codegen --check] {codegenOutPath} missing"
-      return 1
+      IO.eprintln s!"[codegen --check] {t.outPath} missing"
+      return false
     | some onDisk =>
       if onDisk == rustSource then
-        IO.println s!"[codegen --check] {codegenOutPath} up to date \
+        IO.println s!"[codegen --check] {t.outPath} up to date \
           ({rustSource.length} bytes, {compiled.bytecode.functions.size} aiur fns)"
-        return 0
+        return true
       else
-        IO.eprintln s!"[codegen --check] {codegenOutPath} STALE: \
+        IO.eprintln s!"[codegen --check] {t.outPath} STALE: \
           on-disk {onDisk.length} bytes, would emit {rustSource.length} bytes. \
           Re-run `ix codegen` and commit the result."
-        return 1
-  IO.FS.writeFile codegenOutPath rustSource
-  IO.println s!"[codegen] wrote {rustSource.length} bytes to {codegenOutPath} \
+        return false
+  IO.FS.writeFile t.outPath rustSource
+  IO.println s!"[codegen] wrote {rustSource.length} bytes to {t.outPath} \
     ({compiled.bytecode.functions.size} aiur fns)"
-  return 0
+  return true
+
+def runCodegenCmd (p : Cli.Parsed) : IO UInt32 := do
+  let checkOnly := p.hasFlag "check"
+  let mut ok := true
+  for t in targets do
+    ok := (← emitTarget checkOnly t) && ok
+  return if ok then 0 else 1
 
 end Ix.Cli.CodegenCmd
 
 open Ix.Cli.CodegenCmd in
 def codegenCmd : Cli.Cmd := `[Cli|
   "codegen" VIA runCodegenCmd;
-  "Compile the IxVM Aiur kernel to Rust source via the Bytecode → Rust codegen pass. Writes to `crates/ixvm-codegen/src/aiur_ixvm.rs` (fixed path, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces."
+  "Compile the IxVM Aiur kernel and the MultiStark recursive verifier to Rust source via the Bytecode → Rust codegen pass. Writes to `crates/ixvm-codegen/src/aiur_ixvm.rs` and `crates/ixvm-codegen/src/aiur_multi_stark.rs` (fixed paths, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces."
 
   FLAGS:
-    "check"; "CI mode: compare the emitted source against the on-disk file at `crates/ixvm-codegen/src/aiur_ixvm.rs` and exit 0 if identical, 1 otherwise. Does not modify the file."
+    "check"; "CI mode: compare the emitted source against the on-disk files at `crates/ixvm-codegen/src/aiur_ixvm.rs` and `crates/ixvm-codegen/src/aiur_multi_stark.rs` and exit 0 if identical, 1 otherwise. Does not modify the files."
 ]
 
 end
diff --git a/Ix/IxVM.lean b/Ix/IxVM.lean
index 9d7679ab4..23788db2a 100644
--- a/Ix/IxVM.lean
+++ b/Ix/IxVM.lean
@@ -132,13 +132,13 @@ def entrypoints := ⟦
   }
 ⟧
 
-/-- Build the IxVM Aiur toplevel. 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. -/
-def ixVM : Except Aiur.Global Aiur.Source.Toplevel := do
+/-- 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
@@ -160,6 +160,19 @@ def ixVM : Except Aiur.Global Aiur.Source.Toplevel := do
   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/MultiStark.lean b/Ix/MultiStark.lean
index 93254d717..a898ddfc6 100644
--- a/Ix/MultiStark.lean
+++ b/Ix/MultiStark.lean
@@ -44,18 +44,22 @@ def entrypoints := ⟦
   -- docstring. One stream per channel (0 = proof, 1 = vk, 2 = claims), each
   -- registered under key `[0]` on its channel.
   pub fn verify_multi_stark_proof(system_digest: [[U8; 8]; 4], claims_digest: [[U8; 8]; 4], num_queries: G, commit_pow_bits: G, log_blowup: G) {
-    -- Proof advice from IO channel 0: deserialize, assert fully consumed.
+    -- Proof advice from IO channel 0: deserialize directly from the IO arena
+    -- by byte offset (no materialized byte stream), assert fully consumed.
+    -- The byte FETCHES inside the readers are unconstrained (the proof is
+    -- advice — same trust model as the former `#read_byte_stream`); the
+    -- parse structure itself stays constrained.
     let (idx, len) = io_get_info(0, [0]);
-    let bytes = #read_byte_stream(0, idx, len);
-    let (proof, rest) = read_proof(bytes);
-    assert_eq!(load(rest), ListNode.Nil);
+    let (proof, stop) = read_proof(idx);
+    assert_eq!(stop, idx + len);
     -- Verifying key (`System<AiurCircuit>`) from IO channel 1: bind the bytes
-    -- to the public Blake3 `system_digest`, then reconstruct the system.
+    -- to the public Blake3 `system_digest` (hashed straight from the IO arena
+    -- — no byte list), then reconstruct the system via indexed reads and
+    -- assert full consumption.
     let (sidx, slen) = io_get_info(1, [0]);
-    let sbytes = #read_byte_stream(1, sidx, slen);
-    assert_eq!(b3_to_digest(blake3(sbytes)), system_digest);
-    let (sys, srest) = read_system(sbytes);
-    assert_eq!(load(srest), ListNode.Nil);
+    assert_eq!(b3_to_digest(b3_io(1, sidx, slen)), system_digest);
+    let (sys, send) = read_system(sidx);
+    assert_eq!(send, sidx + slen);
     -- Public claims (`&[&[Val]]`) from IO channel 2: bind the bytes to the
     -- public Blake3 `claims_digest`, then deserialize. Binding them as a
     -- public input is what makes the lookup argument sound (a prover cannot
@@ -74,10 +78,12 @@ def entrypoints := ⟦
   }
 ⟧
 
-/-- The standalone Multi-STARK verifier toplevel: `core` (lists/options) +
+/-- The FULL Multi-STARK verifier toplevel: `core` (lists/options) +
 `byteStream` (`U64`, `flatten_u64`, `read_byte_stream`, …) + the deserializer,
-the Blake3 hash, and the entrypoint. -/
-def multiStark : Except Aiur.Global Aiur.Source.Toplevel := do
+the Blake3 hash, and the entrypoint — unpruned, including entries inherited
+from the shared modules (`blake3_test`/`blake3_bench`). Only `multiStarkTests`
+builds on this; production uses `multiStark` (pruned). -/
+def multiStarkFull : Except Aiur.Global Aiur.Source.Toplevel := do
   let t ← IxVM.core.merge IxVM.byteStream
   let t ← t.merge MultiStark.goldilocks
   let t ← t.merge deserialize
@@ -87,6 +93,15 @@ def multiStark : Except Aiur.Global Aiur.Source.Toplevel := do
   let t ← t.merge verifier
   t.merge entrypoints
 
+/-- The production Multi-STARK verifier toplevel: `multiStarkFull` pruned to
+`verify_multi_stark_proof`'s call closure. Every compiled function is a
+committed circuit whose openings pad every proof of the verifier's execution,
+so functions only reachable from unrelated entries (kernel-oriented helpers of
+the shared modules, test/bench entries) cost real proof bytes if kept. -/
+def multiStark : Except Aiur.Global Aiur.Source.Toplevel := do
+  let t ← multiStarkFull
+  pure (t.prune [`verify_multi_stark_proof])
+
 /-! ## Lean-side input assembly
 
 Callers of `verify_multi_stark_proof` (tests, benchmarks) must reproduce the
@@ -108,29 +123,43 @@ def serializeClaims (claims : Array (Array Aiur.G)) : ByteArray := Id.run do
       out := out ++ u64le g.val.toNat
   return ⟨out⟩
 
+/-- Assemble `verify_multi_stark_proof`'s public input from the serialized vk
+(`AiurSystem.vkBytes`) and claims (`serializeClaims`): vk digest ++ claims
+digest ++ the variable FRI parameters. The proof/vk/claims advice itself goes
+through the natively-built IO buffer (`executeMultiStark` /
+`proveMultiStark`, which take the raw byte blobs directly), or through
+`verifierInput` on the Lean-buffer fallback path. -/
+def verifierPubInput (vkBytes claimBytes : ByteArray)
+    (commitParams : Aiur.CommitmentParameters) (friParams : Aiur.FriParameters) :
+    Array Aiur.G :=
+  let digestGs : ByteArray → Array Aiur.G :=
+    fun b => (Blake3.Rust.hash b).val.data.map .ofUInt8
+  digestGs vkBytes ++ digestGs claimBytes ++
+    #[.ofNat friParams.numQueries, .ofNat friParams.commitProofOfWorkBits,
+      .ofNat commitParams.logBlowup]
+
 /-- Assemble `verify_multi_stark_proof`'s inputs from the serialized proof, vk
-(`AiurSystem.vkBytes`), and claims (`serializeClaims`): the public input (vk
-digest ++ claims digest ++ the variable FRI parameters) and the IO buffer
-(channel 0 = proof advice, 1 = vk, 2 = claims, each under key `[0]`). -/
+(`AiurSystem.vkBytes`), and claims (`serializeClaims`): the public input
+(`verifierPubInput`) and the IO buffer (channel 0 = proof advice, 1 = vk,
+2 = claims, each under key `[0]`). The Lean-built buffer boxes every byte
+into a `G` and is marshalled across FFI — prefer the raw-bytes entrypoints
+(`executeMultiStark` / `proveMultiStark`) off the hot path. -/
 def verifierInput (proofBytes vkBytes claimBytes : ByteArray)
     (commitParams : Aiur.CommitmentParameters) (friParams : Aiur.FriParameters) :
     Array Aiur.G × Aiur.IOBuffer :=
   let gs := fun (b : ByteArray) => b.data.map Aiur.G.ofUInt8
-  let digestGs := fun (b : ByteArray) => gs (Blake3.Rust.hash b).val
-  let pubInput := digestGs vkBytes ++ digestGs claimBytes ++
-    #[.ofNat friParams.numQueries, .ofNat friParams.commitProofOfWorkBits,
-      .ofNat commitParams.logBlowup]
+  let pubInput := verifierPubInput vkBytes claimBytes commitParams friParams
   let io := (((default : Aiur.IOBuffer).extend 0 #[.ofNat 0] (gs proofBytes)).extend
     1 #[.ofNat 0] (gs vkBytes)).extend 2 #[.ofNat 0] (gs claimBytes)
   (pubInput, io)
 
 /-- The verifier toplevel PLUS its self-test entrypoints
-(`Ix/MultiStark/Tests.lean`). Kept separate from `multiStark` because every
-`pub fn` adds a circuit to the compiled system — the production verifier should
-not carry test-only width. Use this toplevel only to run the `*_test`
-entrypoints. -/
+(`Ix/MultiStark/Tests.lean`), unpruned. Kept separate from `multiStark`
+because every `pub fn` adds a circuit to the compiled system — the production
+verifier should not carry test-only width. Use this toplevel only to run the
+`*_test` entrypoints. -/
 def multiStarkTests : Except Aiur.Global Aiur.Source.Toplevel := do
-  let t ← multiStark
+  let t ← multiStarkFull
   t.merge tests
 
 end MultiStark
diff --git a/Ix/MultiStark/Deserialize.lean b/Ix/MultiStark/Deserialize.lean
index d814a4347..cac3cad1e 100644
--- a/Ix/MultiStark/Deserialize.lean
+++ b/Ix/MultiStark/Deserialize.lean
@@ -21,8 +21,23 @@ The wire format is bincode `standard().with_little_endian().with_fixed_int_encod
 * `ExtVal` (deg-2 ext)        : `[u64; 2]`, 16 bytes LE
 * Merkle digest               : `[u64; 4]`, 32 bytes LE
 
-`read_proof` builds a `Proof` object; `Ix/MultiStark.lean` hangs the entrypoint
-(and eventual verification logic) off it.
+The proof stream is pure non-deterministic advice on IO channel 0 (never
+hashed — see `Ix/MultiStark.lean`), so the `read_proof` family reads it
+**directly from the IO arena by index**: every reader threads a `(channel-0)
+byte offset `i : G` and pulls fixed-size chunks with `io_read` (1/8/16/32
+bytes — `io_read`'s length is static). No per-byte `ListNode` chain is ever
+materialized, which removes one memory store + one load per proof byte.
+Variable-length content loops a fixed-size read per element, exactly like
+the old stream readers looped `read_u8`.
+
+The byte-stream primitives (`read_u8`/`read_u64`/`read_count`/`read_digest`/
+`read_merkle_cap` over `ByteStream`) remain for the vk/claims streams, whose
+bytes are digest-bound and therefore flow through blake3 as materialized
+streams anyway (`read_system`, `read_claims`).
+
+`read_proof i` builds a `Proof` object and returns the end offset;
+`Ix/MultiStark.lean` hangs the entrypoint (and full-consumption assert)
+off it.
 -/
 
 public section
@@ -37,11 +52,10 @@ def deserialize := ⟦
   -- ==========================================================================
 
   -- `ExtVal = BinomialExtensionField<Goldilocks, 2> = 𝔽_p[X]/(X² - 7)`, stored
-  -- as its two Goldilocks coefficients `[c0, c1]` (= `c0 + c1·X`). Each coefficient
-  -- is a NON-NATIVE Goldilocks element (`[U8; 8]`, canonical LE bytes) so that the
-  -- composition-polynomial arithmetic is field-agnostic — it emulates Goldilocks
-  -- on bytes instead of using Aiur's native (outer) field. See `Goldilocks.lean`.
-  type Ext = [[U8; 8]; 2]
+  -- as its two NATIVE Goldilocks coefficients `[c0, c1]` (= `c0 + c1·X`) —
+  -- Aiur's field is Goldilocks, so extension arithmetic runs natively; byte
+  -- form exists only at ingest/observation boundaries (`Goldilocks.lean`).
+  type Ext = [G; 2]
 
   -- A Merkle digest: `[u64; DIGEST_ELEMS]` with `DIGEST_ELEMS = 4`.
   type Digest = [U64; 4]
@@ -95,8 +109,12 @@ def deserialize := ⟦
   }
 
   -- Mirror of `multi_stark::prover::Proof`, in serialization order.
+  -- `active` is the sparse-activation bitmap over the system's canonical
+  -- circuit set (one 0/1 field value per circuit); every other per-circuit
+  -- sequence in the proof is indexed by ACTIVE position.
   enum Proof {
     Mk(
+      List‹G›,            -- active
       Commitments,        -- commitments
       List‹Ext›,          -- intermediate_accumulators
       List‹U8›,           -- log_degrees
@@ -109,7 +127,8 @@ def deserialize := ⟦
   }
 
   -- ==========================================================================
-  -- Byte-reading primitives. Every reader threads the remaining `ByteStream`.
+  -- Byte-stream primitives (vk/claims streams; digest-bound bytes that flow
+  -- through blake3 as materialized `ByteStream`s).
   -- ==========================================================================
 
   fn read_u8(stream: ByteStream) -> (U8, ByteStream) {
@@ -154,127 +173,152 @@ def deserialize := ⟦
       + 0x100000000000000 * to_field(b[7])
   }
 
-  -- `ExtVal` -> two `u64` limbs (no length prefix), each canonicalized into a
-  -- non-native Goldilocks element (`gl_reduce` maps a non-canonical wire repr,
-  -- e.g. `0` shipped as `p`, to its canonical `< p` bytes).
-  fn read_ext(stream: ByteStream) -> (Ext, ByteStream) {
-    let (a, s0) = read_u64(stream);
-    let (b, s1) = read_u64(s0);
-    ([gl_reduce(a), gl_reduce(b)], s1)
+  -- ==========================================================================
+  -- Indexed proof-stream primitives: read fixed-size chunks straight from the
+  -- IO arena of channel 0 at byte offset `i`, returning the advanced offset.
+  -- The cells come back as unconstrained field advice; `u8_from_field_unsafe`
+  -- reinterprets them exactly as the stream readers did (same trust model —
+  -- the proof is advice, and byte-ness is enforced downstream where needed).
+  -- ==========================================================================
+
+  fn read_u8_at(i: G) -> (U8, G) {
+    let [b] = io_read(0, i, 1);
+    (u8_from_field_unsafe(b), i + 1)
+  }
+
+  fn read_u64_at(i: G) -> (U64, G) {
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = io_read(0, i, 8);
+    ([u8_from_field_unsafe(b0), u8_from_field_unsafe(b1),
+      u8_from_field_unsafe(b2), u8_from_field_unsafe(b3),
+      u8_from_field_unsafe(b4), u8_from_field_unsafe(b5),
+      u8_from_field_unsafe(b6), u8_from_field_unsafe(b7)], i + 8)
+  }
+
+  fn read_count_at(i: G) -> (G, G) {
+    let (val, j) = #read_u64_at(i);
+    (flatten_u64(val), j)
   }
 
+  -- `ExtVal` -> two `u64` limbs (no length prefix), each canonicalized into a
+  -- Goldilocks element (`gl_reduce` maps a non-canonical wire repr, e.g. `0`
+  -- shipped as `p`, to its canonical `< p` bytes).
+  fn read_ext_at(i: G) -> (Ext, G) {
+    let (a, j0) = #read_u64_at(i);
+    let (b, j1) = #read_u64_at(j0);
+    ([gl_val(a), gl_val(b)], j1)
+  }
 
-  -- Merkle digest -> `[u64; 4]`, no length prefix.
-  fn read_digest(stream: ByteStream) -> (Digest, ByteStream) {
-    let (a, s0) = read_u64(stream);
-    let (b, s1) = read_u64(s0);
-    let (c, s2) = read_u64(s1);
-    let (d, s3) = read_u64(s2);
-    ([a, b, c, d], s3)
+  fn read_digest_at(i: G) -> (Digest, G) {
+    let (a, j0) = #read_u64_at(i);
+    let (b, j1) = #read_u64_at(j0);
+    let (c, j2) = #read_u64_at(j1);
+    let (d, j3) = #read_u64_at(j2);
+    ([a, b, c, d], j3)
   }
 
   -- ==========================================================================
-  -- Length-prefixed `Vec<T>` readers. First-order, so one pair per element
-  -- type: `read_T_vec` reads the `u64` length then loops `read_T_vec_n`.
+  -- Length-prefixed `Vec<T>` readers over the indexed proof stream.
+  -- First-order, so one pair per element type: `read_T_vec` reads the `u64`
+  -- length then loops `read_T_vec_n`.
   -- ==========================================================================
 
-  fn read_u8_vec(stream: ByteStream) -> (List‹U8›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_u8_vec_n(s, n)
+  fn read_u8_vec(i: G) -> (List‹U8›, G) {
+    let (n, j) = read_count_at(i);
+    read_u8_vec_n(j, n)
   }
-  fn read_u8_vec_n(stream: ByteStream, n: G) -> (List‹U8›, ByteStream) {
+  fn read_u8_vec_n(i: G, n: G) -> (List‹U8›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_u8(stream);
-        let (rest, s2) = read_u8_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = #read_u8_at(i);
+        let (rest, j2) = read_u8_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_u64_vec(stream: ByteStream) -> (List‹U64›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_u64_vec_n(s, n)
+  fn read_u64_vec(i: G) -> (List‹U64›, G) {
+    let (n, j) = read_count_at(i);
+    read_u64_vec_n(j, n)
   }
-  fn read_u64_vec_n(stream: ByteStream, n: G) -> (List‹U64›, ByteStream) {
+  fn read_u64_vec_n(i: G, n: G) -> (List‹U64›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_u64(stream);
-        let (rest, s2) = read_u64_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = #read_u64_at(i);
+        let (rest, j2) = read_u64_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_ext_vec(stream: ByteStream) -> (List‹Ext›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_ext_vec_n(s, n)
+  fn read_ext_vec(i: G) -> (List‹Ext›, G) {
+    let (n, j) = read_count_at(i);
+    read_ext_vec_n(j, n)
   }
-  fn read_ext_vec_n(stream: ByteStream, n: G) -> (List‹Ext›, ByteStream) {
+  fn read_ext_vec_n(i: G, n: G) -> (List‹Ext›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_ext(stream);
-        let (rest, s2) = read_ext_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_ext_at(i);
+        let (rest, j2) = read_ext_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_digest_vec(stream: ByteStream) -> (List‹Digest›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_digest_vec_n(s, n)
+  fn read_digest_vec_at(i: G) -> (List‹Digest›, G) {
+    let (n, j) = read_count_at(i);
+    read_digest_vec_at_n(j, n)
   }
-  fn read_digest_vec_n(stream: ByteStream, n: G) -> (List‹Digest›, ByteStream) {
+  fn read_digest_vec_at_n(i: G, n: G) -> (List‹Digest›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_digest(stream);
-        let (rest, s2) = read_digest_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_digest_at(i);
+        let (rest, j2) = read_digest_vec_at_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
   -- `Vec<Vec<Val>>` for `BatchOpening.opened_values`.
-  fn read_u64_vec_vec(stream: ByteStream) -> (List‹List‹U64››, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_u64_vec_vec_n(s, n)
+  fn read_u64_vec_vec(i: G) -> (List‹List‹U64››, G) {
+    let (n, j) = read_count_at(i);
+    read_u64_vec_vec_n(j, n)
   }
-  fn read_u64_vec_vec_n(stream: ByteStream, n: G) -> (List‹List‹U64››, ByteStream) {
+  fn read_u64_vec_vec_n(i: G, n: G) -> (List‹List‹U64››, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_u64_vec(stream);
-        let (rest, s2) = read_u64_vec_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_u64_vec(i);
+        let (rest, j2) = read_u64_vec_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
   -- `OpenedRound = Vec<Vec<Vec<Ext>>>`, built bottom-up from `read_ext_vec`.
-  fn read_ext_vec_vec(stream: ByteStream) -> (List‹List‹Ext››, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_ext_vec_vec_n(s, n)
+  fn read_ext_vec_vec(i: G) -> (List‹List‹Ext››, G) {
+    let (n, j) = read_count_at(i);
+    read_ext_vec_vec_n(j, n)
   }
-  fn read_ext_vec_vec_n(stream: ByteStream, n: G) -> (List‹List‹Ext››, ByteStream) {
+  fn read_ext_vec_vec_n(i: G, n: G) -> (List‹List‹Ext››, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_ext_vec(stream);
-        let (rest, s2) = read_ext_vec_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_ext_vec(i);
+        let (rest, j2) = read_ext_vec_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_opened_round(stream: ByteStream) -> (OpenedRound, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_opened_round_n(s, n)
+  fn read_opened_round(i: G) -> (OpenedRound, G) {
+    let (n, j) = read_count_at(i);
+    read_opened_round_n(j, n)
   }
-  fn read_opened_round_n(stream: ByteStream, n: G) -> (OpenedRound, ByteStream) {
+  fn read_opened_round_n(i: G, n: G) -> (OpenedRound, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_ext_vec_vec(stream);
-        let (rest, s2) = read_opened_round_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_ext_vec_vec(i);
+        let (rest, j2) = read_opened_round_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
@@ -282,122 +326,141 @@ def deserialize := ⟦
   -- Struct readers (fields in declaration order, no framing).
   -- ==========================================================================
 
-  fn read_merkle_cap(stream: ByteStream) -> (MerkleCap, ByteStream) {
-    read_digest_vec(stream)
+  fn read_merkle_cap_at(i: G) -> (MerkleCap, G) {
+    read_digest_vec_at(i)
   }
-  fn read_merkle_cap_vec(stream: ByteStream) -> (List‹MerkleCap›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_merkle_cap_vec_n(s, n)
+  fn read_merkle_cap_vec(i: G) -> (List‹MerkleCap›, G) {
+    let (n, j) = read_count_at(i);
+    read_merkle_cap_vec_n(j, n)
   }
-  fn read_merkle_cap_vec_n(stream: ByteStream, n: G) -> (List‹MerkleCap›, ByteStream) {
+  fn read_merkle_cap_vec_n(i: G, n: G) -> (List‹MerkleCap›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_merkle_cap(stream);
-        let (rest, s2) = read_merkle_cap_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_merkle_cap_at(i);
+        let (rest, j2) = read_merkle_cap_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_commitments(stream: ByteStream) -> (Commitments, ByteStream) {
-    let (stage_1_trace, s0) = read_merkle_cap(stream);
-    let (stage_2_trace, s1) = read_merkle_cap(s0);
-    let (quotient_chunks, s2) = read_merkle_cap(s1);
-    (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), s2)
+  fn read_commitments(i: G) -> (Commitments, G) {
+    let (stage_1_trace, j0) = read_merkle_cap_at(i);
+    let (stage_2_trace, j1) = read_merkle_cap_at(j0);
+    let (quotient_chunks, j2) = read_merkle_cap_at(j1);
+    (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2)
   }
 
-  fn read_batch_opening(stream: ByteStream) -> (BatchOpening, ByteStream) {
-    let (opened_values, s0) = read_u64_vec_vec(stream);
-    let (opening_proof, s1) = read_digest_vec(s0);
-    (BatchOpening.Mk(opened_values, opening_proof), s1)
+  fn read_batch_opening(i: G) -> (BatchOpening, G) {
+    let (opened_values, j0) = read_u64_vec_vec(i);
+    let (opening_proof, j1) = read_digest_vec_at(j0);
+    (BatchOpening.Mk(opened_values, opening_proof), j1)
   }
-  fn read_batch_opening_vec(stream: ByteStream) -> (List‹BatchOpening›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_batch_opening_vec_n(s, n)
+  fn read_batch_opening_vec(i: G) -> (List‹BatchOpening›, G) {
+    let (n, j) = read_count_at(i);
+    read_batch_opening_vec_n(j, n)
   }
-  fn read_batch_opening_vec_n(stream: ByteStream, n: G) -> (List‹BatchOpening›, ByteStream) {
+  fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_batch_opening(stream);
-        let (rest, s2) = read_batch_opening_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_batch_opening(i);
+        let (rest, j2) = read_batch_opening_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_commit_phase_step(stream: ByteStream) -> (CommitPhaseProofStep, ByteStream) {
-    let (log_arity, s0) = read_u8(stream);
-    let (sibling_values, s1) = read_ext_vec(s0);
-    let (opening_proof, s2) = read_digest_vec(s1);
-    (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), s2)
+  fn read_commit_phase_step(i: G) -> (CommitPhaseProofStep, G) {
+    let (log_arity, j0) = #read_u8_at(i);
+    let (sibling_values, j1) = read_ext_vec(j0);
+    let (opening_proof, j2) = read_digest_vec_at(j1);
+    (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), j2)
   }
-  fn read_commit_phase_step_vec(stream: ByteStream) -> (List‹CommitPhaseProofStep›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_commit_phase_step_vec_n(s, n)
+  fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseProofStep›, G) {
+    let (n, j) = read_count_at(i);
+    read_commit_phase_step_vec_n(j, n)
   }
-  fn read_commit_phase_step_vec_n(stream: ByteStream, n: G) -> (List‹CommitPhaseProofStep›, ByteStream) {
+  fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_commit_phase_step(stream);
-        let (rest, s2) = read_commit_phase_step_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_commit_phase_step(i);
+        let (rest, j2) = read_commit_phase_step_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_query_proof(stream: ByteStream) -> (QueryProof, ByteStream) {
-    let (input_proof, s0) = read_batch_opening_vec(stream);
-    let (commit_phase_openings, s1) = read_commit_phase_step_vec(s0);
-    (QueryProof.Mk(input_proof, commit_phase_openings), s1)
+  fn read_query_proof(i: G) -> (QueryProof, G) {
+    let (input_proof, j0) = read_batch_opening_vec(i);
+    let (commit_phase_openings, j1) = read_commit_phase_step_vec(j0);
+    (QueryProof.Mk(input_proof, commit_phase_openings), j1)
   }
-  fn read_query_proof_vec(stream: ByteStream) -> (List‹QueryProof›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_query_proof_vec_n(s, n)
+  fn read_query_proof_vec(i: G) -> (List‹QueryProof›, G) {
+    let (n, j) = read_count_at(i);
+    read_query_proof_vec_n(j, n)
   }
-  fn read_query_proof_vec_n(stream: ByteStream, n: G) -> (List‹QueryProof›, ByteStream) {
+  fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_query_proof(stream);
-        let (rest, s2) = read_query_proof_vec_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (x, j) = read_query_proof(i);
+        let (rest, j2) = read_query_proof_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_fri_proof(stream: ByteStream) -> (FriProof, ByteStream) {
-    let (commit_phase_commits, s0) = read_merkle_cap_vec(stream);
-    let (commit_pow_witnesses, s1) = read_u64_vec(s0);
-    let (query_proofs, s2) = read_query_proof_vec(s1);
-    let (final_poly, s3) = read_ext_vec(s2);
-    let (query_pow_witness, s4) = read_u64(s3);
+  fn read_fri_proof(i: G) -> (FriProof, G) {
+    let (commit_phase_commits, j0) = read_merkle_cap_vec(i);
+    let (commit_pow_witnesses, j1) = read_u64_vec(j0);
+    let (query_proofs, j2) = read_query_proof_vec(j1);
+    let (final_poly, j3) = read_ext_vec(j2);
+    let (query_pow_witness, j4) = #read_u64_at(j3);
     (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, query_proofs,
-                 final_poly, query_pow_witness), s4)
+                 final_poly, query_pow_witness), j4)
+  }
+
+  -- The activation bitmap: `Vec<bool>` on the wire (u64 count, then one
+  -- 0/1 byte per circuit), kept as 0/1 field values.
+  fn read_active(i: G) -> (List‹G›, G) {
+    let (n, j) = read_count_at(i);
+    read_active_n(j, n)
+  }
+  fn read_active_n(i: G, n: G) -> (List‹G›, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (b, j) = #read_u8_at(i);
+        let (rest, j2) = read_active_n(j, n - 1);
+        (store(ListNode.Cons(to_field(b), rest)), j2),
+    }
   }
 
   -- `Option<OpenedRound>`: 1 tag byte, then the value when `Some`.
-  fn read_preprocessed(stream: ByteStream) -> (PreprocessedOpt, ByteStream) {
-    let (tag, s) = read_u8(stream);
+  fn read_preprocessed(i: G) -> (PreprocessedOpt, G) {
+    let (tag, j) = #read_u8_at(i);
     match tag {
-      0 => (PreprocessedOpt.NoPreprocessed, s),
+      0 => (PreprocessedOpt.NoPreprocessed, j),
       _ =>
-        let (r, s2) = read_opened_round(s);
-        (PreprocessedOpt.SomePreprocessed(r), s2),
+        let (r, j2) = read_opened_round(j);
+        (PreprocessedOpt.SomePreprocessed(r), j2),
     }
   }
 
-  -- Full `Proof` in declaration order (see `manual_codec.rs::Reader::proof`).
-  fn read_proof(stream: ByteStream) -> (Proof, ByteStream) {
-    let (commitments, s0) = read_commitments(stream);
-    let (intermediate_accumulators, s1) = read_ext_vec(s0);
-    let (log_degrees, s2) = read_u8_vec(s1);
-    let (opening_proof, s3) = read_fri_proof(s2);
-    let (quotient_opened_values, s4) = read_opened_round(s3);
-    let (preprocessed_opened_values, s5) = read_preprocessed(s4);
-    let (stage_1_opened_values, s6) = read_opened_round(s5);
-    let (stage_2_opened_values, s7) = read_opened_round(s6);
-    (Proof.Mk(commitments, intermediate_accumulators, log_degrees, opening_proof,
-              quotient_opened_values, preprocessed_opened_values,
-              stage_1_opened_values, stage_2_opened_values), s7)
+  -- Full `Proof` in declaration order (see `manual_codec.rs::Reader::proof`),
+  -- read from the channel-0 IO arena starting at byte offset `i`. Returns the
+  -- end offset; the entrypoint asserts it equals `idx + len` (fully consumed).
+  fn read_proof(i: G) -> (Proof, G) {
+    let (active, ja) = read_active(i);
+    let (commitments, j0) = read_commitments(ja);
+    let (intermediate_accumulators, j1) = read_ext_vec(j0);
+    let (log_degrees, j2) = read_u8_vec(j1);
+    let (opening_proof, j3) = read_fri_proof(j2);
+    let (quotient_opened_values, j4) = read_opened_round(j3);
+    let (preprocessed_opened_values, j5) = read_preprocessed(j4);
+    let (stage_1_opened_values, j6) = read_opened_round(j5);
+    let (stage_2_opened_values, j7) = read_opened_round(j6);
+    (Proof.Mk(active, commitments, intermediate_accumulators, log_degrees,
+              opening_proof, quotient_opened_values, preprocessed_opened_values,
+              stage_1_opened_values, stage_2_opened_values), j7)
   }
 ⟧
 
diff --git a/Ix/MultiStark/Goldilocks.lean b/Ix/MultiStark/Goldilocks.lean
index 6bfc8c3a8..2453d39c6 100644
--- a/Ix/MultiStark/Goldilocks.lean
+++ b/Ix/MultiStark/Goldilocks.lean
@@ -2,24 +2,34 @@ module
 public import Ix.Aiur.Meta
 
 /-!
-# Non-native Goldilocks field arithmetic (`Goldilocks = [U8; 8]`)
-
-The recursive verifier computes on the *inner* proof's field (Goldilocks),
-but Aiur compiles the verifier to its *own* (outer) field — which is **not
-always Goldilocks** (it may be the BLS scalar field). So inner-field arithmetic
-cannot use Aiur's native `+`/`*` (those compute in the outer field); it must be
-**emulated** on bytes.
-
-A `Goldilocks` element is its canonical value `< p = 2⁶⁴ − 2³² + 1` held as 8
-little-endian bytes (`[U8; 8]`), and `ExtGoldilocks = [Goldilocks; 2]` is the
-degree-2 extension `𝔽_p[X]/(X² − 7)`. All ops are built from the u8 gadgets
-(`u8_add`/`u8_sub`/`u8_mul` give full carry/borrow/16-bit-product), so they are
-field-agnostic and produce bytes directly (no field→byte decomposition needed).
-
-`EPSILON = 2³² − 1`, and `2⁶⁴ ≡ EPSILON (mod p)`, the basis of the reductions.
-
-Validated byte-for-byte against `multi-stark`'s native Goldilocks (`gl_ops_ref`
-in `multi-stark/src/types.rs`).
+# Goldilocks field arithmetic on the native field (`Goldilocks = G`)
+
+The recursive verifier computes on the *inner* proof's field (Goldilocks) —
+and Aiur's outer field IS Goldilocks (`aiur::G = p3_goldilocks`), so the
+arithmetic runs directly on native `+`/`*`. A `Goldilocks` element is a
+plain field value (canonical by construction — `G` is the field), and
+`ExtGoldilocks = [G; 2]` is the degree-2 extension `𝔽_p[X]/(X² − 7)`.
+
+Byte form exists only at true boundaries:
+
+- **ingest**: wire limbs (`U64`, 8 LE bytes, possibly non-canonical) fold
+  into native values with `gl_val`/`limb_to_field` (the field sum wraps
+  mod p — exactly the reduction);
+- **egress**: challenger observations need the canonical LE bytes;
+  `gl_to_bytes` decomposes a native value via the `unconstrained_g_to_bytes`
+  hint, pinned by u8 range checks, a recomposition equality, and a
+  canonicality (`< p`) check — forcing the unique canonical decomposition.
+
+Inverses are hinted (`unconstrained_g_inverse`) and verified with one
+multiplication, never computed.
+
+If Aiur is ever compiled to a different outer field (e.g. the BLS scalar
+field), this module must be swapped for a field-agnostic byte-limb
+implementation (see this file's git history for a complete one, validated
+byte-for-byte against `multi-stark`'s `gl_ops_ref`).
+
+Validated against `multi-stark`'s native Goldilocks (`gl_ops_ref` in
+`multi-stark/src/types.rs`) via the `multi-stark` self-test suite.
 -/
 
 public section
@@ -27,288 +37,113 @@ public section
 namespace MultiStark
 
 def goldilocks := ⟦
-  type Goldilocks = [U8; 8]
-  type ExtGoldilocks = [Goldilocks; 2]
-
-  -- p = 2⁶⁴ − 2³² + 1 and EPSILON = 2³² − 1, little-endian.
-  fn gl_p() -> Goldilocks { [1u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8] }
-  fn gl_eps() -> Goldilocks { [255u8, 255u8, 255u8, 255u8, 0u8, 0u8, 0u8, 0u8] }
-  fn gl_zero() -> Goldilocks { [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] }
-  fn gl_one() -> Goldilocks { [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] }
-
-  -- ==========================================================================
-  -- Byte-vector primitives (carry/borrow chains over the u8 gadgets).
-  -- ==========================================================================
-
-  -- Add two bytes with a carry-in (0/1). Returns (sum byte, carry-out 0/1).
-  -- `u8_add` adds only two bytes; the carry-in is folded with a second add. At
-  -- most one of the two overflow flags fires, so the carry-out stays 0/1.
-  fn adc(a: U8, b: U8, cin: G) -> (U8, G) {
-    let (s1, o1) = u8_add(a, b);
-    let (s2, o2) = u8_add(s1, u8_from_field_unsafe(cin));
-    (s2, to_field(o1) + to_field(o2))
-  }
-
-  -- Subtract two bytes with a borrow-in (0/1). Returns (diff byte, borrow-out).
-  fn sbb(a: U8, b: U8, bin: G) -> (U8, G) {
-    let (d1, w1) = u8_sub(a, b);
-    let (d2, w2) = u8_sub(d1, u8_from_field_unsafe(bin));
-    (d2, to_field(w1) + to_field(w2))
-  }
-
-  -- 8-byte (64-bit) add. Returns the 8-byte sum and the final carry (0/1).
-  fn add8(a: Goldilocks, b: Goldilocks) -> (Goldilocks, G) {
-    let (r0, c0) = adc(a[0], b[0], 0);
-    let (r1, c1) = adc(a[1], b[1], c0);
-    let (r2, c2) = adc(a[2], b[2], c1);
-    let (r3, c3) = adc(a[3], b[3], c2);
-    let (r4, c4) = adc(a[4], b[4], c3);
-    let (r5, c5) = adc(a[5], b[5], c4);
-    let (r6, c6) = adc(a[6], b[6], c5);
-    let (r7, c7) = adc(a[7], b[7], c6);
-    ([r0, r1, r2, r3, r4, r5, r6, r7], c7)
-  }
-
-  -- 8-byte (64-bit) subtract. Returns the 8-byte difference and final borrow.
-  fn sub8(a: Goldilocks, b: Goldilocks) -> (Goldilocks, G) {
-    let (r0, w0) = sbb(a[0], b[0], 0);
-    let (r1, w1) = sbb(a[1], b[1], w0);
-    let (r2, w2) = sbb(a[2], b[2], w1);
-    let (r3, w3) = sbb(a[3], b[3], w2);
-    let (r4, w4) = sbb(a[4], b[4], w3);
-    let (r5, w5) = sbb(a[5], b[5], w4);
-    let (r6, w6) = sbb(a[6], b[6], w5);
-    let (r7, w7) = sbb(a[7], b[7], w6);
-    ([r0, r1, r2, r3, r4, r5, r6, r7], w7)
-  }
-
-  -- Branchless select on a 0/1 flag: `cond ? x : y` (per byte). `cond` is a
-  -- field element in {0,1}; each result byte equals x[i] or y[i] (both < 256),
-  -- so `u8_from_field_unsafe` is safe.
-  fn sel(cond: G, x: U8, y: U8) -> U8 {
-    u8_from_field_unsafe(to_field(x) * cond + to_field(y) * (1 - cond))
-  }
-  fn select8(cond: G, x: Goldilocks, y: Goldilocks) -> Goldilocks {
-    [sel(cond, x[0], y[0]), sel(cond, x[1], y[1]), sel(cond, x[2], y[2]),
-     sel(cond, x[3], y[3]), sel(cond, x[4], y[4]), sel(cond, x[5], y[5]),
-     sel(cond, x[6], y[6]), sel(cond, x[7], y[7])]
-  }
-
-  -- ==========================================================================
-  -- Base field add / sub (mod p).
-  -- ==========================================================================
-
-  -- a + b mod p. The raw sum is `c·2⁶⁴ + s` with `c ∈ {0,1}`, value `< 2p`:
-  --   • c = 1 ⇒ s < p (since 2⁶⁴ > p), and `2⁶⁴ + s − p = s + EPSILON`
-  --     (a non-overflowing add since the true result is < p);
-  --   • c = 0 ⇒ reduce by one conditional subtraction of p (when s ≥ p).
-  fn gl_add(a: Goldilocks, b: Goldilocks) -> Goldilocks {
-    let (s, c) = add8(a, b);
-    let (s_minus_p, borrow) = sub8(s, gl_p());  -- borrow = 1 iff s < p
-    let (s_plus_eps, _) = add8(s, gl_eps());
-    let c0 = select8(1 - borrow, s_minus_p, s); -- c=0 branch: (s≥p ? s−p : s)
-    select8(c, s_plus_eps, c0)
-  }
-
-  -- a − b mod p. `sub8` borrow = 1 iff a < b, in which case the true result is
-  -- `(a − b mod 2⁶⁴) − EPSILON = a − b + p`.
-  fn gl_sub(a: Goldilocks, b: Goldilocks) -> Goldilocks {
-    let (d, borrow) = sub8(a, b);
-    let (d_minus_eps, _) = sub8(d, gl_eps());
-    select8(borrow, d_minus_eps, d)
-  }
-
-  fn gl_neg(a: Goldilocks) -> Goldilocks { gl_sub(gl_zero(), a) }
-  fn gl_seven() -> Goldilocks { [7u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] }
-  fn gl_two() -> Goldilocks { [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] }
-
-  -- Canonicalize an arbitrary 8-byte value (possibly ≥ p, e.g. a raw hash limb
-  -- or a non-canonical wire encoding) to the canonical representative `< p`.
-  -- Any 8-byte value is `< 2⁶⁴ < 2p`, so one conditional subtraction of p
-  -- suffices (borrow = 1 iff x < p ⇒ already canonical).
-  fn gl_reduce(x: Goldilocks) -> Goldilocks {
-    let (xmp, borrow) = sub8(x, gl_p());
-    select8(borrow, x, xmp)
-  }
-
-  -- 1 iff `x` is the field zero (canonicalize first, then test all bytes zero).
-  -- The byte sum is `< 8·256 = 2048`, so `eq_zero` of the sum is field-agnostic.
-  fn gl_is_zero(x: Goldilocks) -> G {
-    let r = gl_reduce(x);
-    eq_zero(to_field(r[0]) + to_field(r[1]) + to_field(r[2]) + to_field(r[3])
-          + to_field(r[4]) + to_field(r[5]) + to_field(r[6]) + to_field(r[7]))
-  }
-
-  -- 1 iff two canonical Goldilocks values are equal (byte-exact). Inputs must be
-  -- canonical (`gl_*` outputs always are); each `to_field` difference is small.
-  fn gl_eq(a: Goldilocks, b: Goldilocks) -> G {
-    eq_zero(to_field(a[0]) - to_field(b[0])) * eq_zero(to_field(a[1]) - to_field(b[1]))
-      * eq_zero(to_field(a[2]) - to_field(b[2])) * eq_zero(to_field(a[3]) - to_field(b[3]))
-      * eq_zero(to_field(a[4]) - to_field(b[4])) * eq_zero(to_field(a[5]) - to_field(b[5]))
-      * eq_zero(to_field(a[6]) - to_field(b[6])) * eq_zero(to_field(a[7]) - to_field(b[7]))
+  type Goldilocks = G
+  type ExtGoldilocks = [G; 2]
+
+  fn gl_zero() -> Goldilocks { 0 }
+  fn gl_one() -> Goldilocks { 1 }
+  fn gl_two() -> Goldilocks { 2 }
+  fn gl_seven() -> Goldilocks { 7 }
+
+  -- The native field value of 8 LE bytes: `Σ xᵢ·256ⁱ` (mod p). For an
+  -- arbitrary 8-byte value (< 2⁶⁴ < 2p) the field sum wraps at most once,
+  -- yielding exactly the reduced representative — so this is both the
+  -- canonical-bytes recomposition AND the wire-limb reduction.
+  fn gl_val(x: [U8; 8]) -> G {
+    to_field(x[0]) + 256 * to_field(x[1]) + 65536 * to_field(x[2])
+      + 16777216 * to_field(x[3]) + 4294967296 * to_field(x[4])
+      + 1099511627776 * to_field(x[5]) + 281474976710656 * to_field(x[6])
+      + 72057594037927936 * to_field(x[7])
+  }
+
+  -- 1 iff the 8-byte LE integer is < p. Since p = (2³² − 1)·2³² + 1, we have
+  -- x ≥ p ⟺ (high word = 2³² − 1) ∧ (low word ≥ 1). The high word is maximal
+  -- iff its byte sum is 4·255 = 1020 (each byte is ≤ 255), and the low word
+  -- is zero iff its byte sum is zero (a sum of four bytes cannot wrap).
+  -- Inputs must be range-checked bytes. (Used by the challenger's rejection
+  -- sampling, which works on raw sampled bytes.)
+  fn gl_lt_p(x: [U8; 8]) -> G {
+    let hi_max = eq_zero(
+      to_field(x[4]) + to_field(x[5]) + to_field(x[6]) + to_field(x[7]) - 1020);
+    let lo_zero = eq_zero(
+      to_field(x[0]) + to_field(x[1]) + to_field(x[2]) + to_field(x[3]));
+    1 - (hi_max * (1 - lo_zero))
+  }
+
+  -- Decompose a native field value into its canonical 8 LE bytes (egress:
+  -- challenger observations). The bytes are prover hints; the range checks +
+  -- recomposition equality + canonicality check pin the unique canonical
+  -- decomposition (two distinct byte strings < p have distinct field values).
+  fn gl_to_bytes(v: G) -> [U8; 8] {
+    let b = unconstrained_g_to_bytes(v);
+    let (c0, c1) = u8_range_check(to_field(b[0]), to_field(b[1]));
+    let (c2, c3) = u8_range_check(to_field(b[2]), to_field(b[3]));
+    let (c4, c5) = u8_range_check(to_field(b[4]), to_field(b[5]));
+    let (c6, c7) = u8_range_check(to_field(b[6]), to_field(b[7]));
+    let r = [c0, c1, c2, c3, c4, c5, c6, c7];
+    assert_eq!(gl_val(r), v);
+    assert_eq!(gl_lt_p(r), 1);
+    r
   }
 
   -- ==========================================================================
-  -- Base field multiply (mod p): schoolbook 64×64 → 128-bit product, then the
-  -- Goldilocks `reduce128` (ported from Plonky3 `goldilocks.rs`).
+  -- Base field ops: native.
   -- ==========================================================================
-
-  -- 8-byte × 1-byte → 9-byte product (`a · m`, with `a < 2⁶⁴`, `m < 2⁸`, so the
-  -- result is `< 2⁷²`). Column `k` is `lo_k + hi_{k-1} + carry`, and the carry
-  -- provably stays in {0,1} (each column sum ≤ 255+255+1 = 511 < 512).
-  fn mul1(a: Goldilocks, m: U8) -> [U8; 9] {
-    let (l0, h0) = u8_mul(a[0], m);
-    let (l1, h1) = u8_mul(a[1], m);
-    let (l2, h2) = u8_mul(a[2], m);
-    let (l3, h3) = u8_mul(a[3], m);
-    let (l4, h4) = u8_mul(a[4], m);
-    let (l5, h5) = u8_mul(a[5], m);
-    let (l6, h6) = u8_mul(a[6], m);
-    let (l7, h7) = u8_mul(a[7], m);
-    let (r1, c1) = adc(l1, h0, 0);
-    let (r2, c2) = adc(l2, h1, c1);
-    let (r3, c3) = adc(l3, h2, c2);
-    let (r4, c4) = adc(l4, h3, c3);
-    let (r5, c5) = adc(l5, h4, c4);
-    let (r6, c6) = adc(l6, h5, c5);
-    let (r7, c7) = adc(l7, h6, c6);
-    let (r8, _)  = adc(h7, 0u8, c7);
-    [l0, r1, r2, r3, r4, r5, r6, r7, r8]
-  }
-
-  -- 16-byte (128-bit) add, carry chain. The final carry is discarded (used only
-  -- to accumulate partial-product rows whose total provably fits in 128 bits).
-  fn add16(x: [U8; 16], y: [U8; 16]) -> [U8; 16] {
-    let (r0,  c0)  = adc(x[0],  y[0],  0);
-    let (r1,  c1)  = adc(x[1],  y[1],  c0);
-    let (r2,  c2)  = adc(x[2],  y[2],  c1);
-    let (r3,  c3)  = adc(x[3],  y[3],  c2);
-    let (r4,  c4)  = adc(x[4],  y[4],  c3);
-    let (r5,  c5)  = adc(x[5],  y[5],  c4);
-    let (r6,  c6)  = adc(x[6],  y[6],  c5);
-    let (r7,  c7)  = adc(x[7],  y[7],  c6);
-    let (r8,  c8)  = adc(x[8],  y[8],  c7);
-    let (r9,  c9)  = adc(x[9],  y[9],  c8);
-    let (r10, c10) = adc(x[10], y[10], c9);
-    let (r11, c11) = adc(x[11], y[11], c10);
-    let (r12, c12) = adc(x[12], y[12], c11);
-    let (r13, c13) = adc(x[13], y[13], c12);
-    let (r14, c14) = adc(x[14], y[14], c13);
-    let (r15, _)   = adc(x[15], y[15], c14);
-    [r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15]
-  }
-
-  -- Full 64×64 → 128-bit product as 16 little-endian bytes. Eight single-byte
-  -- rows `a · b[i]`, each shifted left by `i` bytes and accumulated.
-  fn mul128(a: Goldilocks, b: Goldilocks) -> [U8; 16] {
-    let m0 = mul1(a, b[0]);
-    let m1 = mul1(a, b[1]);
-    let m2 = mul1(a, b[2]);
-    let m3 = mul1(a, b[3]);
-    let m4 = mul1(a, b[4]);
-    let m5 = mul1(a, b[5]);
-    let m6 = mul1(a, b[6]);
-    let m7 = mul1(a, b[7]);
-    let acc = [m0[0], m0[1], m0[2], m0[3], m0[4], m0[5], m0[6], m0[7], m0[8],
-               0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
-    let rb1 = [0u8, m1[0], m1[1], m1[2], m1[3], m1[4], m1[5], m1[6], m1[7], m1[8],
-               0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
-    let acc = add16(acc, rb1);
-    let rb2 = [0u8, 0u8, m2[0], m2[1], m2[2], m2[3], m2[4], m2[5], m2[6], m2[7], m2[8],
-               0u8, 0u8, 0u8, 0u8, 0u8];
-    let acc = add16(acc, rb2);
-    let rb3 = [0u8, 0u8, 0u8, m3[0], m3[1], m3[2], m3[3], m3[4], m3[5], m3[6], m3[7], m3[8],
-               0u8, 0u8, 0u8, 0u8];
-    let acc = add16(acc, rb3);
-    let rb4 = [0u8, 0u8, 0u8, 0u8, m4[0], m4[1], m4[2], m4[3], m4[4], m4[5], m4[6], m4[7], m4[8],
-               0u8, 0u8, 0u8];
-    let acc = add16(acc, rb4);
-    let rb5 = [0u8, 0u8, 0u8, 0u8, 0u8, m5[0], m5[1], m5[2], m5[3], m5[4], m5[5], m5[6], m5[7], m5[8],
-               0u8, 0u8];
-    let acc = add16(acc, rb5);
-    let rb6 = [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, m6[0], m6[1], m6[2], m6[3], m6[4], m6[5], m6[6], m6[7], m6[8],
-               0u8];
-    let acc = add16(acc, rb6);
-    let rb7 = [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, m7[0], m7[1], m7[2], m7[3], m7[4], m7[5], m7[6], m7[7], m7[8]];
-    add16(acc, rb7)
-  }
-
-  -- Reduce a 128-bit value (16 LE bytes) mod p. Port of Plonky3 `reduce128`:
-  -- with `x = x_lo + x_hi·2⁶⁴`, split `x_hi = x_hi_lo + x_hi_hi·2³²`; then
-  -- `2⁶⁴ ≡ EPSILON` and `2⁹⁶ ≡ −1` give `x ≡ x_lo − x_hi_hi + x_hi_lo·EPSILON`.
-  -- A final conditional subtraction of p canonicalizes (Plonky3 keeps a
-  -- non-canonical u64; we need the canonical bytes).
-  fn reduce128(p: [U8; 16]) -> Goldilocks {
-    let xlo = [p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]];
-    let xhl = [p[8], p[9], p[10], p[11], 0u8, 0u8, 0u8, 0u8];   -- low 32 bits of x_hi
-    let xhh = [p[12], p[13], p[14], p[15], 0u8, 0u8, 0u8, 0u8]; -- high 32 bits of x_hi
-    -- t0 = x_lo − x_hi_hi (subtract EPSILON on borrow; cannot underflow).
-    let (t0w, borrow) = sub8(xlo, xhh);
-    let (t0b, _) = sub8(t0w, gl_eps());
-    let t0 = select8(borrow, t0b, t0w);
-    -- t1 = x_hi_lo · EPSILON  (< 2⁶⁴, so only the low 8 product bytes matter).
-    let t1full = mul128(xhl, gl_eps());
-    let t1 = [t1full[0], t1full[1], t1full[2], t1full[3],
-              t1full[4], t1full[5], t1full[6], t1full[7]];
-    -- t2 = t0 + t1  (add EPSILON on overflow; result stays < 2⁶⁴).
-    let (t2w, carry) = add8(t0, t1);
-    let (t2c, _) = add8(t2w, gl_eps());
-    let t2 = select8(carry, t2c, t2w);
-    -- canonicalize: borrow2 = 1 iff t2 < p ⇒ keep t2, else subtract p.
-    let (t2mp, borrow2) = sub8(t2, gl_p());
-    select8(borrow2, t2, t2mp)
-  }
-
-  fn gl_mul(a: Goldilocks, b: Goldilocks) -> Goldilocks { reduce128(mul128(a, b)) }
-  fn gl_sq(a: Goldilocks) -> Goldilocks { gl_mul(a, a) }
+  fn gl_add(a: Goldilocks, b: Goldilocks) -> Goldilocks { a + b }
+  fn gl_sub(a: Goldilocks, b: Goldilocks) -> Goldilocks { a - b }
+  fn gl_neg(a: Goldilocks) -> Goldilocks { 0 - a }
+  fn gl_mul(a: Goldilocks, b: Goldilocks) -> Goldilocks { a * b }
+  fn gl_sq(a: Goldilocks) -> Goldilocks { a * a }
+  fn gl_is_zero(x: Goldilocks) -> G { eq_zero(x) }
+  fn gl_eq(a: Goldilocks, b: Goldilocks) -> G { eq_zero(a - b) }
 
   -- ==========================================================================
-  -- Base field inverse / divide via Fermat: a⁻¹ = a^(p−2).
-  -- p − 2 = 2⁶⁴ − 2³² − 1 — in binary: bit 32 is 0, every other bit is 1
-  -- (31 ones, one zero, 32 ones). `gl_run` applies `n` steps of `acc ← acc²·b`.
+  -- Base field inverse / divide: hinted, verified with one multiplication.
+  -- `t = x·i − 1; x·t == 0 ∧ i·t == 0` forces `i = x⁻¹` when `x ≠ 0` (first
+  -- assert gives x·i = 1) and `i = 0` when `x = 0` (t = −1, second assert).
+  -- Matches the reference semantics `0⁻¹ = 0` (Fermat: 0^(p−2) = 0).
   -- ==========================================================================
-  fn gl_run(acc: Goldilocks, base: Goldilocks, n: G) -> Goldilocks {
-    match n {
-      0 => acc,
-      _ => gl_run(gl_mul(gl_sq(acc), base), base, n - 1),
-    }
-  }
   fn gl_inverse(x: Goldilocks) -> Goldilocks {
-    let acc = gl_run(x, x, 30);  -- bits 63..33: 31 ones (initial acc = x is bit 63)
-    let acc = gl_sq(acc);        -- bit 32: a single 0
-    gl_run(acc, x, 32)           -- bits 31..0: 32 ones
+    let iv = unconstrained_g_inverse(x);
+    let t = (x * iv) - 1;
+    assert_eq!(x * t, 0);
+    assert_eq!(iv * t, 0);
+    iv
   }
-  fn gl_div(a: Goldilocks, b: Goldilocks) -> Goldilocks { gl_mul(a, gl_inverse(b)) }
+  fn gl_div(a: Goldilocks, b: Goldilocks) -> Goldilocks { a * gl_inverse(b) }
 
   -- ==========================================================================
-  -- Extension field ExtGoldilocks = 𝔽_p[X]/(X² − 7).
+  -- Extension field ExtGoldilocks = 𝔽_p[X]/(X² − 7), native end-to-end.
   -- ==========================================================================
   fn eg_add(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
-    [gl_add(a[0], b[0]), gl_add(a[1], b[1])]
+    [a[0] + b[0], a[1] + b[1]]
   }
   fn eg_sub(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
-    [gl_sub(a[0], b[0]), gl_sub(a[1], b[1])]
+    [a[0] - b[0], a[1] - b[1]]
   }
   fn eg_neg(a: ExtGoldilocks) -> ExtGoldilocks {
-    [gl_neg(a[0]), gl_neg(a[1])]
+    [0 - a[0], 0 - a[1]]
   }
   -- (a0 + a1·X)(b0 + b1·X) = (a0·b0 + 7·a1·b1) + (a0·b1 + a1·b0)·X.
   fn eg_mul(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
-    [gl_add(gl_mul(a[0], b[0]), gl_mul(gl_seven(), gl_mul(a[1], b[1]))),
-     gl_add(gl_mul(a[0], b[1]), gl_mul(a[1], b[0]))]
+    [(a[0] * b[0]) + (7 * (a[1] * b[1])), (a[0] * b[1]) + (a[1] * b[0])]
   }
   -- conjugate ā = a0 − a1·X, norm a·ā = a0² − 7·a1² ∈ 𝔽_p, a⁻¹ = ā / norm.
+  -- The norm inverse is hinted and pinned like `gl_inverse`.
   fn eg_inverse(a: ExtGoldilocks) -> ExtGoldilocks {
-    let norm = gl_sub(gl_sq(a[0]), gl_mul(gl_seven(), gl_sq(a[1])));
-    let ninv = gl_inverse(norm);
-    [gl_mul(a[0], ninv), gl_mul(gl_neg(a[1]), ninv)]
+    let norm = (a[0] * a[0]) - (7 * (a[1] * a[1]));
+    let ninv = unconstrained_g_inverse(norm);
+    let t = (norm * ninv) - 1;
+    assert_eq!(norm * t, 0);
+    assert_eq!(ninv * t, 0);
+    [a[0] * ninv, (0 - a[1]) * ninv]
   }
   fn eg_div(a: ExtGoldilocks, b: ExtGoldilocks) -> ExtGoldilocks {
     eg_mul(a, eg_inverse(b))
   }
-  -- 1 iff two extension elements are equal (both coordinates byte-exact).
+  -- 1 iff two extension elements are equal.
   fn eg_eq(a: ExtGoldilocks, b: ExtGoldilocks) -> G {
-    gl_eq(a[0], b[0]) * gl_eq(a[1], b[1])
+    eq_zero(a[0] - b[0]) * eq_zero(a[1] - b[1])
   }
 
 ⟧
diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs.lean
index 85dc2227d..9a902bc28 100644
--- a/Ix/MultiStark/Pcs.lean
+++ b/Ix/MultiStark/Pcs.lean
@@ -71,19 +71,215 @@ def pcs := ⟦
      [h[4][0], h[4][1], h[4][2], h[4][3], 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]]]
   }
-  -- The 32 bytes of a `Digest`.
-  fn b3_digest_bytes_onto(d: Digest, tail: ByteStream) -> ByteStream {
-    b3_u64_onto(d[0], b3_u64_onto(d[1], b3_u64_onto(d[2], b3_u64_onto(d[3], tail))))
+  -- ==========================================================================
+  -- Lane-granular blake3 for MMCS leaf rows. A leaf's input is a `List‹U64›`
+  -- of 8-byte lanes, so blocks (64 bytes = 8 lanes) can be assembled straight
+  -- from the lane values — one list `load` per lane — instead of serializing
+  -- to a byte list that `blake3` then walks, re-accumulates, and re-loads
+  -- (~4 memory ops per byte). Mirrors `blake3_compress_chunks`/`_block`/
+  -- `_finish` at block granularity with the identical flag schedule
+  -- (CHUNK_START = 1, CHUNK_END = 2, ROOT = 8; chunk = 16 blocks), reusing
+  -- `blake3_compress` and the `Layer` chunk-tree fold unchanged.
+  -- ==========================================================================
+
+  -- Pop up to 8 lanes (one block), zero-padding the tail. Returns the block's
+  -- lanes, its real byte length (8·k, so 64 for a full block), and the rest.
+  fn b3_lane_block(lanes: List‹U64›) -> ([U64; 8], G, List‹U64›) {
+    let z = [0u8; 8];
+    match load(lanes) {
+      ListNode.Nil => ([z; 8], 0, lanes),
+      ListNode.Cons(v0, r0) => match load(r0) {
+        ListNode.Nil => ([v0, z, z, z, z, z, z, z], 8, r0),
+        ListNode.Cons(v1, r1) => match load(r1) {
+          ListNode.Nil => ([v0, v1, z, z, z, z, z, z], 16, r1),
+          ListNode.Cons(v2, r2) => match load(r2) {
+            ListNode.Nil => ([v0, v1, v2, z, z, z, z, z], 24, r2),
+            ListNode.Cons(v3, r3) => match load(r3) {
+              ListNode.Nil => ([v0, v1, v2, v3, z, z, z, z], 32, r3),
+              ListNode.Cons(v4, r4) => match load(r4) {
+                ListNode.Nil => ([v0, v1, v2, v3, v4, z, z, z], 40, r4),
+                ListNode.Cons(v5, r5) => match load(r5) {
+                  ListNode.Nil => ([v0, v1, v2, v3, v4, v5, z, z], 48, r5),
+                  ListNode.Cons(v6, r6) => match load(r6) {
+                    ListNode.Nil => ([v0, v1, v2, v3, v4, v5, v6, z], 56, r6),
+                    ListNode.Cons(v7, r7) =>
+                      ([v0, v1, v2, v3, v4, v5, v6, v7], 64, r7),
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+  }
+
+  -- Block-granular chunk walk. `block_no` is the block index within the
+  -- current chunk (0..15); `cv` is the chaining value (IV at each chunk start);
+  -- chunk digests are pushed onto `layer` in order, exactly like the byte
+  -- driver, and folded by `blake3_compress_layer` at the end.
+  fn b3_lane_chunks(lanes: List‹U64›, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: &Layer) -> &Layer {
+    match load(lanes) {
+      -- Exhausted with no block to compress: only reachable for an empty
+      -- input (every other path detects exhaustion after compressing).
+      -- Mirror of `blake3_finish`'s (0, 0) arm.
+      ListNode.Nil =>
+        match load(chunk_count) {
+          [0, 0, 0, 0, 0, 0, 0, 0] =>
+            store(Layer.Push(layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))),
+          _ => layer,
+        },
+      _ =>
+        let (v, nbytes, rest) = b3_lane_block(lanes);
+        let block = [
+          [v[0][0], v[0][1], v[0][2], v[0][3]], [v[0][4], v[0][5], v[0][6], v[0][7]],
+          [v[1][0], v[1][1], v[1][2], v[1][3]], [v[1][4], v[1][5], v[1][6], v[1][7]],
+          [v[2][0], v[2][1], v[2][2], v[2][3]], [v[2][4], v[2][5], v[2][6], v[2][7]],
+          [v[3][0], v[3][1], v[3][2], v[3][3]], [v[3][4], v[3][5], v[3][6], v[3][7]],
+          [v[4][0], v[4][1], v[4][2], v[4][3]], [v[4][4], v[4][5], v[4][6], v[4][7]],
+          [v[5][0], v[5][1], v[5][2], v[5][3]], [v[5][4], v[5][5], v[5][6], v[5][7]],
+          [v[6][0], v[6][1], v[6][2], v[6][3]], [v[6][4], v[6][5], v[6][6], v[6][7]],
+          [v[7][0], v[7][1], v[7][2], v[7][3]], [v[7][4], v[7][5], v[7][6], v[7][7]]];
+        let empty = match load(rest) { ListNode.Nil => 1, _ => 0, };
+        let at15 = eq_zero(block_no - 15);
+        -- CHUNK_START on the chunk's first block; CHUNK_END iff this is the
+        -- chunk's 16th block OR the input ends here; ROOT only for the last
+        -- block of a single-chunk input (multi-chunk roots come from the
+        -- layer fold's PARENT+ROOT, as in the byte driver).
+        let start_flag = eq_zero(block_no);
+        let end_flag = empty + at15 - (empty * at15);
+        let root_flag = empty * u64_is_zero(load(chunk_count));
+        let flags = start_flag + 2 * end_flag + 8 * root_flag;
+        let digest = blake3_compress(load(cv), block, load(chunk_count), nbytes, flags);
+        match (empty, at15) {
+          (1, _) => store(Layer.Push(layer, digest)),
+          (_, 1) =>
+            let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
+            b3_lane_chunks(rest, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(Layer.Push(layer, digest))),
+          (_, _) => b3_lane_chunks(rest, block_no + 1, chunk_count, store(digest), layer),
+        },
+    }
+  }
+
+  -- ==========================================================================
+  -- blake3 straight from an IO channel arena: 64-byte `io_read` blocks fed
+  -- directly to `blake3_compress` — no byte list is materialized, walked,
+  -- accumulated, or re-loaded. Same flag schedule as the byte driver; the
+  -- (cold, once-per-hash) ≤63-byte tail reuses `pad_block`/`bytes_to_block`.
+  -- Used for digest-binding large advice streams (the verifying key).
+  -- ==========================================================================
+
+  -- Reverse-ordered tail accumulator (head = last byte), the shape
+  -- `pad_block`/`bytes_to_block` expect. Reads one byte per step (io_read's
+  -- length is static); at most 63 steps, once per hash.
+  fn b3_io_tail_acc(ch: G, i: G, n: G, acc: ByteStream) -> ByteStream {
+    match n {
+      0 => acc,
+      _ =>
+        let [b] = io_read(ch, i, 1);
+        b3_io_tail_acc(ch, i + 1, n - 1,
+          store(ListNode.Cons(u8_from_field_unsafe(b), acc))),
+    }
+  }
+
+  fn b3_io_chunks(ch: G, i: G, remaining: G, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: &Layer) -> &Layer {
+    match u32_less_than(remaining, 64) {
+      0 =>
+        -- A full 64-byte block is available.
+        let [b0, 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,
+             b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47,
+             b48, b49, b50, b51, b52, b53, b54, b55, b56, b57, b58, b59, b60, b61, b62, b63] =
+          io_read(ch, i, 64);
+        let block = [
+          [u8_from_field_unsafe(b0), u8_from_field_unsafe(b1), u8_from_field_unsafe(b2), u8_from_field_unsafe(b3)],
+          [u8_from_field_unsafe(b4), u8_from_field_unsafe(b5), u8_from_field_unsafe(b6), u8_from_field_unsafe(b7)],
+          [u8_from_field_unsafe(b8), u8_from_field_unsafe(b9), u8_from_field_unsafe(b10), u8_from_field_unsafe(b11)],
+          [u8_from_field_unsafe(b12), u8_from_field_unsafe(b13), u8_from_field_unsafe(b14), u8_from_field_unsafe(b15)],
+          [u8_from_field_unsafe(b16), u8_from_field_unsafe(b17), u8_from_field_unsafe(b18), u8_from_field_unsafe(b19)],
+          [u8_from_field_unsafe(b20), u8_from_field_unsafe(b21), u8_from_field_unsafe(b22), u8_from_field_unsafe(b23)],
+          [u8_from_field_unsafe(b24), u8_from_field_unsafe(b25), u8_from_field_unsafe(b26), u8_from_field_unsafe(b27)],
+          [u8_from_field_unsafe(b28), u8_from_field_unsafe(b29), u8_from_field_unsafe(b30), u8_from_field_unsafe(b31)],
+          [u8_from_field_unsafe(b32), u8_from_field_unsafe(b33), u8_from_field_unsafe(b34), u8_from_field_unsafe(b35)],
+          [u8_from_field_unsafe(b36), u8_from_field_unsafe(b37), u8_from_field_unsafe(b38), u8_from_field_unsafe(b39)],
+          [u8_from_field_unsafe(b40), u8_from_field_unsafe(b41), u8_from_field_unsafe(b42), u8_from_field_unsafe(b43)],
+          [u8_from_field_unsafe(b44), u8_from_field_unsafe(b45), u8_from_field_unsafe(b46), u8_from_field_unsafe(b47)],
+          [u8_from_field_unsafe(b48), u8_from_field_unsafe(b49), u8_from_field_unsafe(b50), u8_from_field_unsafe(b51)],
+          [u8_from_field_unsafe(b52), u8_from_field_unsafe(b53), u8_from_field_unsafe(b54), u8_from_field_unsafe(b55)],
+          [u8_from_field_unsafe(b56), u8_from_field_unsafe(b57), u8_from_field_unsafe(b58), u8_from_field_unsafe(b59)],
+          [u8_from_field_unsafe(b60), u8_from_field_unsafe(b61), u8_from_field_unsafe(b62), u8_from_field_unsafe(b63)]];
+        let is_last = eq_zero(remaining - 64);
+        let at15 = eq_zero(block_no - 15);
+        let start_flag = eq_zero(block_no);
+        let end_flag = is_last + at15 - (is_last * at15);
+        let root_flag = is_last * u64_is_zero(load(chunk_count));
+        let flags = start_flag + 2 * end_flag + 8 * root_flag;
+        let digest = blake3_compress(load(cv), block, load(chunk_count), 64, flags);
+        match (is_last, at15) {
+          (1, _) => store(Layer.Push(layer, digest)),
+          (_, 1) =>
+            let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
+            b3_io_chunks(ch, i + 64, remaining - 64, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(Layer.Push(layer, digest))),
+          (_, _) => b3_io_chunks(ch, i + 64, remaining - 64, block_no + 1, chunk_count, store(digest), layer),
+        },
+      _ =>
+        -- Partial tail (< 64 bytes): always the input's last block.
+        match remaining {
+          0 =>
+            -- Empty input from the very start. Mirror of `blake3_finish`'s
+            -- (0, 0) arm (any other path compresses before exhausting).
+            match load(chunk_count) {
+              [0, 0, 0, 0, 0, 0, 0, 0] =>
+                store(Layer.Push(layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))),
+              _ => layer,
+            },
+          _ =>
+            let block = bytes_to_block(pad_block(
+              b3_io_tail_acc(ch, i, remaining, store(ListNode.Nil)), 64 - remaining));
+            let start_flag = eq_zero(block_no);
+            let flags = start_flag + 2 + 8 * u64_is_zero(load(chunk_count));
+            store(Layer.Push(layer, blake3_compress(load(cv), block, load(chunk_count), remaining, flags))),
+        },
+    }
+  }
+
+  -- blake3 of `len` bytes at offset `idx` on IO channel `ch` (identical
+  -- output to `blake3` over those bytes — pinned by `io_hash_test`).
+  fn b3_io(ch: G, idx: G, len: G) -> [[U8; 4]; 8] {
+    let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
+    blake3_compress_layer(load(b3_io_chunks(ch, idx, len, 0, store([0u8; 8]), store(IV), store(Layer.Nil))))
+  }
+
+  -- blake3 of a lane list (identical output to `blake3` over the lanes' LE
+  -- bytes — pinned by the `lane_hash_test` differential self-test).
+  fn b3_lanes(lanes: List‹U64›) -> [[U8; 4]; 8] {
+    let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
+    blake3_compress_layer(load(b3_lane_chunks(lanes, 0, store([0u8; 8]), store(IV), store(Layer.Nil))))
   }
 
   -- The MMCS leaf hash of a row (`SerializingHasher<Blake3>`).
   fn mmcs_hash_row(row: List‹U64›) -> Digest {
-    b3_to_digest(blake3(b3_row_onto(row, store(ListNode.Nil))))
+    b3_to_digest(b3_lanes(row))
   }
   -- The MMCS 2-to-1 compression (`CompressionFunctionFromHasher<Blake3, 2, 32>`).
+  -- `a || b` is exactly 64 bytes = one blake3 block of a single chunk, so this
+  -- is one direct `blake3_compress` with the same parameters that input takes
+  -- through `blake3_compress_chunks`: cv = IV, counter = 0, block_len = 64,
+  -- flags = CHUNK_START + CHUNK_END + ROOT (1 + 2 + 8). The block words are
+  -- assembled straight from the digest lanes (each `U64` lane = two LE 4-byte
+  -- words) — no byte list is built, walked, re-accumulated, or re-loaded.
   fn mmcs_compress(a: Digest, b: Digest) -> Digest {
-    b3_to_digest(blake3(b3_digest_bytes_onto(a,
-      b3_digest_bytes_onto(b, store(ListNode.Nil)))))
+    let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
+    let block = [
+      [a[0][0], a[0][1], a[0][2], a[0][3]], [a[0][4], a[0][5], a[0][6], a[0][7]],
+      [a[1][0], a[1][1], a[1][2], a[1][3]], [a[1][4], a[1][5], a[1][6], a[1][7]],
+      [a[2][0], a[2][1], a[2][2], a[2][3]], [a[2][4], a[2][5], a[2][6], a[2][7]],
+      [a[3][0], a[3][1], a[3][2], a[3][3]], [a[3][4], a[3][5], a[3][6], a[3][7]],
+      [b[0][0], b[0][1], b[0][2], b[0][3]], [b[0][4], b[0][5], b[0][6], b[0][7]],
+      [b[1][0], b[1][1], b[1][2], b[1][3]], [b[1][4], b[1][5], b[1][6], b[1][7]],
+      [b[2][0], b[2][1], b[2][2], b[2][3]], [b[2][4], b[2][5], b[2][6], b[2][7]],
+      [b[3][0], b[3][1], b[3][2], b[3][3]], [b[3][4], b[3][5], b[3][6], b[3][7]]];
+    b3_to_digest(blake3_compress(IV, block, [0u8; 8], 64, 11))
   }
 
   -- ==========================================================================
@@ -158,13 +354,108 @@ def pcs := ⟦
   fn canon_lanes(l: List‹U64›) -> List‹U64› {
     match load(l) {
       ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(x, rest) => store(ListNode.Cons(gl_reduce(x), canon_lanes(rest))),
+      ListNode.Cons(x, rest) => store(ListNode.Cons(gl_to_bytes(gl_val(x)), canon_lanes(rest))),
+    }
+  }
+  -- ==========================================================================
+  -- Rows-walking leaf hash: hash the selected rows' lanes directly, with
+  -- on-the-fly canonicalization — no concatenated lane list is ever
+  -- materialized (`concat_at` rebuilt every selected lane per query, and
+  -- `canon_lanes` copied the result again). Differentially pinned against
+  -- the concat + canon reference by `rows_hash_test`.
+  -- ==========================================================================
+
+  -- The rows at log-height `target`, dropped if empty (an empty row
+  -- contributes no bytes, and dropping it lets exhaustion be detected by
+  -- plain Nil checks in the block walker).
+  fn select_rows(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹List‹U64›› {
+    match load(rows) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(r, rrest) =>
+        let &ListNode.Cons(lh, lrest) = lhs;
+        match eq_zero(lh - target) {
+          0 => select_rows(rrest, lrest, target),
+          _ => match load(r) {
+            ListNode.Nil => select_rows(rrest, lrest, target),
+            _ => store(ListNode.Cons(r, select_rows(rrest, lrest, target))),
+          },
+        },
     }
   }
-  -- The joint leaf hash of all matrices at log-height `target`.
+
+  -- Pop one canonicalized lane across row boundaries. `got = 0` iff both the
+  -- current row and the remaining rows are exhausted (selected rows are
+  -- non-empty, so advancing to the next row always yields a lane).
+  fn rows_pop(cur: List‹U64›, rows: List‹List‹U64››) -> (U64, List‹U64›, List‹List‹U64››, G) {
+    match load(cur) {
+      ListNode.Cons(x, rest) => (gl_to_bytes(gl_val(x)), rest, rows, 1),
+      ListNode.Nil => match load(rows) {
+        ListNode.Nil => ([0u8; 8], cur, rows, 0),
+        ListNode.Cons(r, rrest) => rows_pop(r, rrest),
+      },
+    }
+  }
+
+  -- Block-granular chunk walk over rows-of-lanes; mirrors `b3_lane_chunks`
+  -- (same flag schedule, same `Layer` fold), gathering each 64-byte block
+  -- with eight cross-row pops.
+  fn b3_rows_chunks(cur: List‹U64›, rows: List‹List‹U64››, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: &Layer) -> &Layer {
+    let (l0, c1, r1, g0) = rows_pop(cur, rows);
+    match g0 {
+      -- Exhausted with no block to compress: only reachable for an empty
+      -- input (every other path detects exhaustion after compressing).
+      0 =>
+        match load(chunk_count) {
+          [0, 0, 0, 0, 0, 0, 0, 0] =>
+            store(Layer.Push(layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))),
+          _ => layer,
+        },
+      _ =>
+        let (l1, c2, r2, g1) = rows_pop(c1, r1);
+        let (l2, c3, r3, g2) = rows_pop(c2, r2);
+        let (l3, c4, r4, g3) = rows_pop(c3, r3);
+        let (l4, c5, r5, g4) = rows_pop(c4, r4);
+        let (l5, c6, r6, g5) = rows_pop(c5, r5);
+        let (l6, c7, r7, g6) = rows_pop(c6, r6);
+        let (l7, c8, r8, g7) = rows_pop(c7, r7);
+        let nbytes = 8 * (g0 + g1 + g2 + g3 + g4 + g5 + g6 + g7);
+        let block = [
+          [l0[0], l0[1], l0[2], l0[3]], [l0[4], l0[5], l0[6], l0[7]],
+          [l1[0], l1[1], l1[2], l1[3]], [l1[4], l1[5], l1[6], l1[7]],
+          [l2[0], l2[1], l2[2], l2[3]], [l2[4], l2[5], l2[6], l2[7]],
+          [l3[0], l3[1], l3[2], l3[3]], [l3[4], l3[5], l3[6], l3[7]],
+          [l4[0], l4[1], l4[2], l4[3]], [l4[4], l4[5], l4[6], l4[7]],
+          [l5[0], l5[1], l5[2], l5[3]], [l5[4], l5[5], l5[6], l5[7]],
+          [l6[0], l6[1], l6[2], l6[3]], [l6[4], l6[5], l6[6], l6[7]],
+          [l7[0], l7[1], l7[2], l7[3]], [l7[4], l7[5], l7[6], l7[7]]];
+        let empty = match load(c8) {
+          ListNode.Nil => match load(r8) { ListNode.Nil => 1, _ => 0, },
+          _ => 0,
+        };
+        let at15 = eq_zero(block_no - 15);
+        let start_flag = eq_zero(block_no);
+        let end_flag = empty + at15 - (empty * at15);
+        let root_flag = empty * u64_is_zero(load(chunk_count));
+        let flags = start_flag + 2 * end_flag + 8 * root_flag;
+        let digest = blake3_compress(load(cv), block, load(chunk_count), nbytes, flags);
+        match (empty, at15) {
+          (1, _) => store(Layer.Push(layer, digest)),
+          (_, 1) =>
+            let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
+            b3_rows_chunks(c8, r8, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(Layer.Push(layer, digest))),
+          (_, _) => b3_rows_chunks(c8, r8, block_no + 1, chunk_count, store(digest), layer),
+        },
+    }
+  }
+
+  fn b3_rows(rows: List‹List‹U64››) -> [[U8; 4]; 8] {
+    let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
+    blake3_compress_layer(load(b3_rows_chunks(store(ListNode.Nil), rows, 0, store([0u8; 8]), store(IV), store(Layer.Nil))))
+  }
+
+  -- The joint Blake3 leaf hash of all matrices at log-height `target`.
   fn leaf_hash_at(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> Digest {
-    -- The joint Blake3 leaf hash of all matrices at log-height `target`.
-    mmcs_hash_row(canon_lanes(concat_at(rows, lhs, target)))
+    b3_to_digest(b3_rows(select_rows(rows, lhs, target)))
   }
 
   -- Inject the leaf hash of any matrices at log-height `lh` (if present) via a
@@ -235,10 +526,10 @@ def pcs := ⟦
   }
 
   -- base^(Σ bits_i · 2^i), bits LSB-first (square-and-multiply over the bits).
-  -- `base` is a non-native Goldilocks element; `bits` is a native bit list.
-  fn exp_by_bits(base: [U8; 8], bits: List‹G›) -> [U8; 8] {
+  -- `base` is a native Goldilocks element; `bits` is a native bit list.
+  fn exp_by_bits(base: Goldilocks, bits: List‹G›) -> Goldilocks {
     match load(bits) {
-      ListNode.Nil => gl_one(),
+      ListNode.Nil => 1,
       ListNode.Cons(b, rest) =>
         let half = exp_by_bits(gl_sq(base), rest);
         match b {
@@ -254,8 +545,8 @@ def pcs := ⟦
     let g = two_adic_gen(log_height + 1);
     let s = exp_by_bits(g, glist_rev(index_bits, store(ListNode.Nil)));
     let two_s = gl_add(s, s);
-    let t1 = eg_div(eg_add(e0, e1), [gl_two(), gl_zero()]);
-    let t2 = eg_mul(beta, eg_div(eg_sub(e0, e1), [two_s, gl_zero()]));
+    let t1 = eg_div(eg_add(e0, e1), [2, 0]);
+    let t2 = eg_mul(beta, eg_div(eg_sub(e0, e1), [two_s, 0]));
     eg_add(t1, t2)
   }
 
@@ -274,18 +565,27 @@ def pcs := ⟦
 
   -- The base-field query domain point x. `index_bits` = low-`log_height` index
   -- bits, LSB first (so reverse_bits_len = reversing the list).
-  fn ro_x(index_bits: List‹G›, log_height: G) -> [U8; 8] {
-    gl_mul(gl_seven(), exp_by_bits(two_adic_gen(log_height), glist_rev(index_bits, store(ListNode.Nil))))
+  fn ro_x(index_bits: List‹G›, log_height: G) -> Goldilocks {
+    gl_mul(7, exp_by_bits(two_adic_gen(log_height), glist_rev(index_bits, store(ListNode.Nil))))
+  }
+
+  -- Raw wire rows (`U64` lanes, possibly non-canonical) to native Goldilocks
+  -- values for the reduced-opening arithmetic (`limb_to_field` reduces mod p).
+  fn lanes_to_gl(l: List‹U64›) -> List‹Goldilocks› {
+    match load(l) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(x, rest) => store(ListNode.Cons(limb_to_field(x), lanes_to_gl(rest))),
+    }
   }
 
   -- Accumulate one matrix-point's column contributions. `q = 1/(z − x)`.
-  fn ro_fold(p_x: List‹[U8; 8]›, p_z: List‹Ext›, q: Ext, alpha: Ext, ro: Ext, ap: Ext)
+  fn ro_fold(p_x: List‹Goldilocks›, p_z: List‹Ext›, q: Ext, alpha: Ext, ro: Ext, ap: Ext)
       -> (Ext, Ext) {
     match load(p_x) {
       ListNode.Nil => (ro, ap),
       ListNode.Cons(px, pxr) =>
         let &ListNode.Cons(pz, pzr) = p_z;
-        let term = eg_mul(eg_mul(ap, eg_sub(pz, [px, gl_zero()])), q);
+        let term = eg_mul(eg_mul(ap, eg_sub(pz, [px, 0])), q);
         ro_fold(pxr, pzr, q, alpha, eg_add(ro, term), eg_mul(ap, alpha)),
     }
   }
@@ -306,29 +606,35 @@ def pcs := ⟦
   enum Bucket { Mk(G, Ext, Ext) }   -- log_height, alpha_pow, reduced_opening
 
   -- ── challenger: observe the opened values (observe_algebra_slice) ──────────
+  -- Built with the PREPEND helpers (`b8_onto` composition, O(1) per element),
+  -- front-to-back, so the whole observation batch costs one `list_concat` at
+  -- the end. Appending item-by-item onto the accumulated input (`snoc_b8`)
+  -- re-walks and rebuilds the entire buffer per observation — quadratic in
+  -- transcript size; at kernel scale the opened-values batch alone made that
+  -- billions of memory records.
   -- One ext element = its two base coordinates, each 8 LE bytes.
-  fn obs_ext_row(input: ByteStream, row: List‹Ext›) -> ByteStream {
+  fn ext_row_onto(row: List‹Ext›, tail: ByteStream) -> ByteStream {
     match load(row) {
-      ListNode.Nil => input,
-      ListNode.Cons(e, rest) => obs_ext_row(snoc_b8(snoc_b8(input, e[0]), e[1]), rest),
+      ListNode.Nil => tail,
+      ListNode.Cons(e, rest) => b8_onto(gl_to_bytes(e[0]), b8_onto(gl_to_bytes(e[1]), ext_row_onto(rest, tail))),
     }
   }
-  fn obs_points(input: ByteStream, pts: List‹List‹Ext››) -> ByteStream {
+  fn points_onto(pts: List‹List‹Ext››, tail: ByteStream) -> ByteStream {
     match load(pts) {
-      ListNode.Nil => input,
-      ListNode.Cons(row, rest) => obs_points(obs_ext_row(input, row), rest),
+      ListNode.Nil => tail,
+      ListNode.Cons(row, rest) => ext_row_onto(row, points_onto(rest, tail)),
     }
   }
-  fn obs_round(input: ByteStream, round: OpenedRound) -> ByteStream {
+  fn round_onto(round: OpenedRound, tail: ByteStream) -> ByteStream {
     match load(round) {
-      ListNode.Nil => input,
-      ListNode.Cons(mat, rest) => obs_round(obs_points(input, mat), rest),
+      ListNode.Nil => tail,
+      ListNode.Cons(mat, rest) => points_onto(mat, round_onto(rest, tail)),
     }
   }
-  fn obs_prep(input: ByteStream, prep_opt: PreprocessedOpt) -> ByteStream {
+  fn prep_onto(prep_opt: PreprocessedOpt, tail: ByteStream) -> ByteStream {
     match prep_opt {
-      PreprocessedOpt.NoPreprocessed => input,
-      PreprocessedOpt.SomePreprocessed(round) => obs_round(input, round),
+      PreprocessedOpt.NoPreprocessed => tail,
+      PreprocessedOpt.SomePreprocessed(round) => round_onto(round, tail),
     }
   }
   -- Observe one Val (= 1) per FRI round, the variable-arity schedule.
@@ -365,7 +671,7 @@ def pcs := ⟦
         let (i1, o1) = pcs_commit_pow(snoc_cap(input, c), w, bits);
         let (b0, b1, i2, _o) = ch_sample_ext(i1, o1);
         let (bs, i3) = pcs_betas(i2, rest, wrest, bits);
-        (store(ListNode.Cons([gl_reduce(b0), gl_reduce(b1)], bs)), i3),
+        (store(ListNode.Cons([gl_val(b0), gl_val(b1)], bs)), i3),
     }
   }
 
@@ -394,14 +700,14 @@ def pcs := ⟦
       _ => match circ_has_height(log_degrees, log_blowup, num_circuits, 0, h) {
         0 => build_buckets(log_degrees, log_blowup, num_circuits, h - 1),
         _ => store(ListNode.Cons(
-               Bucket.Mk(h, [gl_one(), gl_zero()], [gl_zero(), gl_zero()]),
+               Bucket.Mk(h, [1, 0], [0, 0]),
                build_buckets(log_degrees, log_blowup, num_circuits, h - 1))),
       },
     }
   }
   -- Find the bucket at log-height `lh`, fold one matrix-point's columns into it
   -- (`ro_fold` threads its `alpha_pow`), and write it back.
-  fn bucket_update(buckets: List‹Bucket›, lh: G, p_x: List‹[U8; 8]›, p_z: List‹Ext›,
+  fn bucket_update(buckets: List‹Bucket›, lh: G, p_x: List‹Goldilocks›, p_z: List‹Ext›,
       q: Ext, alpha: Ext) -> List‹Bucket› {
     match load(buckets) {
       ListNode.Nil => store(ListNode.Nil),
@@ -424,7 +730,7 @@ def pcs := ⟦
       ListNode.Cons(b, rest) =>
         let Bucket.Mk(h, _ap, ro) = b;
         match eq_zero(h - log_blowup) {
-          1 => assert_eq!(eg_eq(ro, [gl_zero(), gl_zero()]), 1); 1,
+          1 => assert_eq!(eg_eq(ro, [0, 0]), 1); 1,
           _ => assert_blowup_zero(rest, log_blowup),
         },
     }
@@ -439,23 +745,23 @@ def pcs := ⟦
   }
   -- Compute x = GENERATOR·g^{revbits} for this height and fold the contribution.
   fn ri_apply(buckets: List‹Bucket›, lh: G, idxbits: List‹G›, log_gmax: G,
-      z: Ext, p_x: List‹[U8; 8]›, p_z: List‹Ext›, alpha: Ext) -> List‹Bucket› {
+      z: Ext, p_x: List‹Goldilocks›, p_z: List‹Ext›, alpha: Ext) -> List‹Bucket› {
     -- the base opening and the ext opening at this point must have equal width
     -- (PointEvaluationCountMismatch); `ro_fold` walks them in lockstep.
     assert_eq!(eq_zero(list_length(p_x) - list_length(p_z)), 1);
     let x = ro_x(list_drop(idxbits, log_gmax - lh), lh);
-    let q = eg_inverse(eg_sub(z, [x, gl_zero()]));
+    let q = eg_inverse(eg_sub(z, [x, 0]));
     bucket_update(buckets, lh, p_x, p_z, q, alpha)
   }
 
   -- A stage_1/stage_2/preprocessed-style matrix: two opening points
   -- (ζ, ζ·g) with the same base row `p_x`. `g` = trace subgroup generator.
   fn open_2pt_mat(buckets: List‹Bucket›, idxbits: List‹G›, log_gmax: G, lh: G,
-      ldeg: G, zeta: Ext, p_x: List‹[U8; 8]›, mat: List‹List‹Ext››, alpha: Ext)
+      ldeg: G, zeta: Ext, p_x: List‹Goldilocks›, mat: List‹List‹Ext››, alpha: Ext)
       -> List‹Bucket› {
     let pz0 = list_lookup(mat, 0);
     let pz1 = list_lookup(mat, 1);
-    let zn = eg_mul(zeta, [two_adic_gen(ldeg), gl_zero()]);
+    let zn = eg_mul(zeta, [two_adic_gen(ldeg), 0]);
     let b1 = ri_apply(buckets, lh, idxbits, log_gmax, zeta, p_x, pz0, alpha);
     ri_apply(b1, lh, idxbits, log_gmax, zn, p_x, pz1, alpha)
   }
@@ -467,7 +773,7 @@ def pcs := ⟦
       _ =>
         let ldeg = to_field(list_lookup(log_degrees, ci));
         let b = open_2pt_mat(buckets, idxbits, log_gmax, ldeg + log_blowup, ldeg, zeta,
-                  list_lookup(base_rows, ci), list_lookup(opened, ci), alpha);
+                  lanes_to_gl(list_lookup(base_rows, ci)), list_lookup(opened, ci), alpha);
         open_batch_2pt(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, log_degrees, zeta,
                        base_rows, opened, alpha),
     }
@@ -481,7 +787,7 @@ def pcs := ⟦
       0 => (buckets, chunk),
       _ =>
         let b = ri_apply(buckets, lh, idxbits, log_gmax, zeta,
-                  list_lookup(base_rows, chunk), list_lookup(list_lookup(q_opened, chunk), 0), alpha);
+                  lanes_to_gl(list_lookup(base_rows, chunk)), list_lookup(list_lookup(q_opened, chunk), 0), alpha);
         open_q_chunks(b, idxbits, log_gmax, lh, chunk + 1, qrem - 1, zeta, base_rows, q_opened, alpha),
     }
   }
@@ -513,7 +819,7 @@ def pcs := ⟦
         OptIdx.SomeIdx(_j) =>
           let ldeg = to_field(list_lookup(log_degrees, ci));
           let b = open_2pt_mat(buckets, idxbits, log_gmax, ldeg + log_blowup, ldeg, zeta,
-                    list_lookup(base_rows, k), list_lookup(prep_round, k), alpha);
+                    lanes_to_gl(list_lookup(base_rows, k)), list_lookup(prep_round, k), alpha);
           open_prep(b, idxbits, log_gmax, log_blowup, ci + 1, rem - 1, k + 1, log_degrees,
                     prep_indices, zeta, base_rows, prep_round, alpha),
       },
@@ -575,8 +881,8 @@ def pcs := ⟦
   }
   -- Flatten two ext evals to the 4 base coords of the ExtensionMmcs leaf row.
   fn flatten2(e0: Ext, e1: Ext) -> List‹U64› {
-    store(ListNode.Cons(e0[0], store(ListNode.Cons(e0[1],
-      store(ListNode.Cons(e1[0], store(ListNode.Cons(e1[1], store(ListNode.Nil)))))))))
+    store(ListNode.Cons(gl_to_bytes(e0[0]), store(ListNode.Cons(gl_to_bytes(e0[1]),
+      store(ListNode.Cons(gl_to_bytes(e1[0]), store(ListNode.Cons(gl_to_bytes(e1[1]), store(ListNode.Nil)))))))))
   }
   -- Roll the next reduced opening into the folded eval when its height matches
   -- the new folded height: `folded += beta^(2^log_arity) · ro`  (log_arity = 1).
@@ -701,18 +1007,19 @@ def pcs := ⟦
     assert_eq!(eq_zero(list_length(pw) - num_rounds), 1);
     assert_eq!(eq_zero(list_length(query_proofs) - num_queries), 1);
     assert_eq!(list_length(final_poly), 1);
-    -- challenger continuation: observe all opened values (coms_to_verify order)
-    let input = obs_round(post_zeta_input, stage1);
-    let input = obs_round(input, stage2);
-    let input = obs_round(input, q_opened);
-    let input = obs_prep(input, prep_opt);
+    -- challenger continuation: observe all opened values (coms_to_verify
+    -- order), built as one front-to-back suffix + a single concat (the input
+    -- is only ~32 bytes here — it collapses to the digest on every flush).
+    let obs = round_onto(stage1, round_onto(stage2, round_onto(q_opened,
+      prep_onto(prep_opt, store(ListNode.Nil)))));
+    let input = list_concat(post_zeta_input, obs);
     -- PCS batch-combination challenge α
     let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil));
-    let alpha = [gl_reduce(a0), gl_reduce(a1)];
+    let alpha = [gl_val(a0), gl_val(a1)];
     -- per-round FRI fold challenges β (with commit-phase PoW), then observe
     -- final_poly + the log-arity schedule.
     let (betas, input) = pcs_betas(input, commit_phase_commits, pw, commit_pow_bits);
-    let input = obs_ext_row(input, final_poly);
+    let input = list_concat(input, ext_row_onto(final_poly, store(ListNode.Nil)));
     let input = obs_log_arities(input, commit_phase_commits);
     -- query indices + per-query verification (log_global_max_height = #rounds + log_blowup)
     let log_gmax = num_rounds + log_blowup;
diff --git a/Ix/MultiStark/SystemDeserialize.lean b/Ix/MultiStark/SystemDeserialize.lean
index 1d76594aa..4cb4a544c 100644
--- a/Ix/MultiStark/SystemDeserialize.lean
+++ b/Ix/MultiStark/SystemDeserialize.lean
@@ -7,21 +7,30 @@ public import Ix.MultiStark.Deserialize
 /-!
 # Verifying-key deserializer (Aiur)
 
-Aiur port of `src/aiur/vk_codec.rs::manual_deserialize` — reconstructs the
-verifier's `System<AiurCircuit>` from the bytes the prover places on the IO
-channel. Same bincode wire format the Rust side validated against serde:
-
-* enum tag       : `u32`, 4 bytes LE
-* `Option`       : 1 tag byte (`0` = None, `1` = Some)
-* `usize`/`u64`  : 8 bytes LE
-* `Vec<T>`       : `u64` length, then elements
-* struct         : fields in declaration order
-* `Range<usize>` : `start`, `end` (two `u64`)
-* `MerkleCap`    : `Vec<[u64; 4]>`
-* Goldilocks `G` : raw `u64`, 8 bytes LE (reduced mod p on read)
-
-Reuses the proof deserializer's byte primitives (`read_u8`, `read_u64`,
-`read_count`, `read_merkle_cap`, `limb_to_field`, `Digest`, `MerkleCap`).
+Aiur port of `crates/aiur/src/vk_codec.rs` — reconstructs the verifier's
+`System<AiurCircuit>` from the bytes the prover places on the IO channel.
+
+Split-streams wire format (v2, mirrors `vk_codec.rs` — see its module docs
+for the full layout): a global header (7 × u16 parameters + u16 circuit
+count), then one contiguous record per circuit — 5 × u32 segment lengths
+followed by the TAGS / IDX / C2 / C8 / META segments — then the trailer
+(preprocessed commit + u16 preprocessed indices, `0xFFFF` = None). Every
+field class has a single fixed width, so all reads are static-size
+`io_read` chunks:
+
+* TAGS : 1 byte per node — low nibble = kind, high nibble = aux
+         (Variable: entry kind + 8·rotation; Constant: size class)
+* IDX  : u16 per Variable (column index)
+* C2   : u16 per small constant; C8 : u64 per large constant
+* META : u32 per count / metadata field
+
+`degree_multiple` is not on the wire (and unused by the verifier — the
+constraint folder just evaluates the tree), so `SymExpr` no longer carries
+it. The vk stream (IO channel 1) is read by byte offset — the readers
+thread one cursor per segment; the record header binds the cursors and the
+per-record end asserts pin each segment's exact consumption. The leaf
+fetches are unconstrained — the digest binding (`b3_io` over the whole
+arena) is what makes the bytes meaningful.
 -/
 
 public section
@@ -33,9 +42,10 @@ def systemDeserialize := ⟦
   -- Reconstructed `System<AiurCircuit>` as Aiur data.
   -- ==========================================================================
 
-  -- `SymbolicVariable.entry` (a column reference within the window).
+  -- `SymbolicVariable.entry` (a column reference within the window). The
+  -- payload of Preprocessed/Main/Stage2 is the rotation offset (0 or 1).
   enum SysEntry {
-    Preprocessed(G),   -- offset
+    Preprocessed(G),
     Main(G),
     Stage2(G),
     Public,
@@ -43,18 +53,19 @@ def systemDeserialize := ⟦
     Challenge
   }
 
-  -- `SymbolicExpression<G>` — the AIR constraint tree. Children are pointers;
-  -- the trailing `G` on Add/Sub/Neg/Mul is the cached `degree_multiple`.
+  -- `SymbolicExpression<G>` — the AIR constraint tree. Children are pointers.
+  -- (`degree_multiple` is not materialized: the wire drops it and the
+  -- constraint folder never reads it.)
   enum SymExpr {
     Var(SysEntry, G),            -- entry, index
     IsFirstRow,
     IsLastRow,
     IsTransition,
-    Const([U8; 8]),             -- a non-native Goldilocks constant (canonical LE bytes)
-    Add(&SymExpr, &SymExpr, G),
-    Sub(&SymExpr, &SymExpr, G),
-    Neg(&SymExpr, G),
-    Mul(&SymExpr, &SymExpr, G)
+    Const(G),                   -- a native Goldilocks constant (reduced on read)
+    Add(&SymExpr, &SymExpr),
+    Sub(&SymExpr, &SymExpr),
+    Neg(&SymExpr),
+    Mul(&SymExpr, &SymExpr)
   }
 
   enum SysLookup { Mk(SymExpr, List‹SymExpr›) }          -- multiplicity, args
@@ -86,231 +97,289 @@ def systemDeserialize := ⟦
   enum OptIdx { NoIdx, SomeIdx(G) }
 
   -- parameters, transcript limbs, circuits, preprocessed_commit,
-  -- preprocessed_indices. The transcript limbs are the raw u64 wire words the
+  -- preprocessed_indices. The transcript limbs are the u64 words the
   -- challenger observes before any commitment — the 7 parameters (bound via
   -- the challenger seed) followed by the system shape (`observe_shape`: the
   -- circuit count, then 6 metadata words per circuit) — kept as limbs because
-  -- the Fiat-Shamir replay needs their little-endian bytes.
+  -- the Fiat-Shamir replay needs their little-endian bytes. The OBSERVED
+  -- values are width-independent, so the narrow wire fields pad to the same
+  -- 8-byte limbs v1 produced.
   enum Sys { Mk(SysParams, List‹U64›, List‹SysCircuit›, OptCommit, List‹OptIdx›) }
 
   -- ==========================================================================
-  -- Byte primitives specific to the VK format.
+  -- Indexed byte primitives over the vk stream (IO channel 1). Fixed-size
+  -- chunks only; each returns the advanced cursor. The `_limb` variants also
+  -- return the value's 8-LE-byte u64 limb for the Fiat-Shamir replay.
   -- ==========================================================================
 
-  -- A `u32` enum tag: 4 little-endian bytes folded into a field element.
-  fn read_u32(stream: ByteStream) -> (G, ByteStream) {
-    let (b0, s0) = read_u8(stream);
-    let (b1, s1) = read_u8(s0);
-    let (b2, s2) = read_u8(s1);
-    let (b3, s3) = read_u8(s2);
-    (to_field(b0) + 0x100 * to_field(b1) + 0x10000 * to_field(b2)
-       + 0x1000000 * to_field(b3), s3)
+  fn read_vk_u8(i: G) -> (U8, G) {
+    let [b] = io_read(1, i, 1);
+    (u8_from_field_unsafe(b), i + 1)
   }
 
-  -- A raw `u64` Goldilocks constant, canonicalized into non-native Goldilocks
-  -- bytes (`gl_reduce`) so it can feed the byte-emulated composition arithmetic.
-  fn read_field(stream: ByteStream) -> ([U8; 8], ByteStream) {
-    let (u, s) = read_u64(stream);
-    (gl_reduce(u), s)
+  -- A TAGS byte, kept as a raw field value for match dispatch.
+  fn read_vk_tag(i: G) -> (G, G) {
+    let [b] = io_read(1, i, 1);
+    (b, i + 1)
   }
 
-  -- ==========================================================================
-  -- Recursive readers (mirror `vk_codec` reader-by-reader).
-  -- ==========================================================================
+  fn read_vk_u16(i: G) -> (G, G) {
+    let [b0, b1] = io_read(1, i, 2);
+    (b0 + 0x100 * b1, i + 2)
+  }
 
-  fn read_sys_entry(stream: ByteStream) -> (SysEntry, ByteStream) {
-    let (tag, s) = read_u32(stream);
-    match tag {
-      0 => let (o, s1) = read_count(s); (SysEntry.Preprocessed(o), s1),
-      1 => let (o, s1) = read_count(s); (SysEntry.Main(o), s1),
-      2 => let (o, s1) = read_count(s); (SysEntry.Stage2(o), s1),
-      3 => (SysEntry.Public, s),
-      4 => (SysEntry.Stage2Public, s),
-      _ => (SysEntry.Challenge, s),
+  fn read_vk_u16_limb(i: G) -> (G, U64, G) {
+    let [b0, b1] = io_read(1, i, 2);
+    (b0 + 0x100 * b1,
+     [u8_from_field_unsafe(b0), u8_from_field_unsafe(b1),
+      0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+     i + 2)
+  }
+
+  fn read_vk_u32(i: G) -> (G, G) {
+    let [b0, b1, b2, b3] = io_read(1, i, 4);
+    (b0 + 0x100 * b1 + 0x10000 * b2 + 0x1000000 * b3, i + 4)
+  }
+
+  fn read_vk_u32_limb(i: G) -> (G, U64, G) {
+    let [b0, b1, b2, b3] = io_read(1, i, 4);
+    (b0 + 0x100 * b1 + 0x10000 * b2 + 0x1000000 * b3,
+     [u8_from_field_unsafe(b0), u8_from_field_unsafe(b1),
+      u8_from_field_unsafe(b2), u8_from_field_unsafe(b3),
+      0u8, 0u8, 0u8, 0u8],
+     i + 4)
+  }
+
+  fn read_vk_u64(i: G) -> (U64, G) {
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = io_read(1, i, 8);
+    ([u8_from_field_unsafe(b0), u8_from_field_unsafe(b1),
+      u8_from_field_unsafe(b2), u8_from_field_unsafe(b3),
+      u8_from_field_unsafe(b4), u8_from_field_unsafe(b5),
+      u8_from_field_unsafe(b6), u8_from_field_unsafe(b7)], i + 8)
+  }
+
+  -- A large (C8) Goldilocks constant, reduced into a native field value so it
+  -- can feed the composition arithmetic directly.
+  fn read_field(i: G) -> (G, G) {
+    let (u, j) = #read_vk_u64(i);
+    (gl_val(u), j)
+  }
+
+  fn read_vk_digest(i: G) -> (Digest, G) {
+    let (a, j0) = #read_vk_u64(i);
+    let (b, j1) = #read_vk_u64(j0);
+    let (c, j2) = #read_vk_u64(j1);
+    let (d, j3) = #read_vk_u64(j2);
+    ([a, b, c, d], j3)
+  }
+  fn read_vk_cap_n(i: G, n: G) -> (MerkleCap, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = read_vk_digest(i);
+        let (rest, j2) = read_vk_cap_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
     }
   }
 
-  fn read_sym_expr(stream: ByteStream) -> (SymExpr, ByteStream) {
-    let (tag, s) = read_u32(stream);
+  -- ==========================================================================
+  -- Expression reader. Cursors: t = TAGS, x = IDX, a = C2, b = C8. The tag
+  -- byte packs kind (low nibble) + aux (high nibble); the match keys are the
+  -- whole byte values (kind + 16·aux).
+  -- ==========================================================================
+
+  fn read_sym_expr(t: G, x: G, a: G, b: G) -> (SymExpr, G, G, G, G) {
+    let (tag, t1) = #read_vk_tag(t);
     match tag {
-      0 =>
-        let (e, s1) = read_sys_entry(s);
-        let (i, s2) = read_count(s1);
-        (SymExpr.Var(e, i), s2),
-      1 => (SymExpr.IsFirstRow, s),
-      2 => (SymExpr.IsLastRow, s),
-      3 => (SymExpr.IsTransition, s),
-      4 => let (c, s1) = read_field(s); (SymExpr.Const(c), s1),
+      -- Var: aux = entry kind + 8·rotation
+      0 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Preprocessed(0), i), t1, x1, a, b),
+      16 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Main(0), i), t1, x1, a, b),
+      32 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Stage2(0), i), t1, x1, a, b),
+      48 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Public, i), t1, x1, a, b),
+      64 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Stage2Public, i), t1, x1, a, b),
+      80 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Challenge, i), t1, x1, a, b),
+      128 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Preprocessed(1), i), t1, x1, a, b),
+      144 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Main(1), i), t1, x1, a, b),
+      160 => let (i, x1) = #read_vk_u16(x); (SymExpr.Var(SysEntry.Stage2(1), i), t1, x1, a, b),
+      1 => (SymExpr.IsFirstRow, t1, x, a, b),
+      2 => (SymExpr.IsLastRow, t1, x, a, b),
+      3 => (SymExpr.IsTransition, t1, x, a, b),
+      -- Const: aux = size class (0 -> C2, 1 -> C8)
+      4 => let (c, a1) = #read_vk_u16(a); (SymExpr.Const(c), t1, x, a1, b),
+      20 => let (c, b1) = #read_field(b); (SymExpr.Const(c), t1, x, a, b1),
       5 =>
-        let (x, s1) = read_sym_expr(s);
-        let (y, s2) = read_sym_expr(s1);
-        let (d, s3) = read_count(s2);
-        (SymExpr.Add(store(x), store(y), d), s3),
+        let (l, t2, x2, a2, b2) = read_sym_expr(t1, x, a, b);
+        let (r, t3, x3, a3, b3) = read_sym_expr(t2, x2, a2, b2);
+        (SymExpr.Add(store(l), store(r)), t3, x3, a3, b3),
       6 =>
-        let (x, s1) = read_sym_expr(s);
-        let (y, s2) = read_sym_expr(s1);
-        let (d, s3) = read_count(s2);
-        (SymExpr.Sub(store(x), store(y), d), s3),
+        let (l, t2, x2, a2, b2) = read_sym_expr(t1, x, a, b);
+        let (r, t3, x3, a3, b3) = read_sym_expr(t2, x2, a2, b2);
+        (SymExpr.Sub(store(l), store(r)), t3, x3, a3, b3),
       7 =>
-        let (x, s1) = read_sym_expr(s);
-        let (d, s2) = read_count(s1);
-        (SymExpr.Neg(store(x), d), s2),
+        let (l, t2, x2, a2, b2) = read_sym_expr(t1, x, a, b);
+        (SymExpr.Neg(store(l)), t2, x2, a2, b2),
       _ =>
-        let (x, s1) = read_sym_expr(s);
-        let (y, s2) = read_sym_expr(s1);
-        let (d, s3) = read_count(s2);
-        (SymExpr.Mul(store(x), store(y), d), s3),
+        let (l, t2, x2, a2, b2) = read_sym_expr(t1, x, a, b);
+        let (r, t3, x3, a3, b3) = read_sym_expr(t2, x2, a2, b2);
+        (SymExpr.Mul(store(l), store(r)), t3, x3, a3, b3),
     }
   }
 
-  fn read_sym_exprs(stream: ByteStream) -> (List‹SymExpr›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_sym_exprs_n(s, n)
-  }
-  fn read_sym_exprs_n(stream: ByteStream, n: G) -> (List‹SymExpr›, ByteStream) {
+  fn read_sym_exprs_n(t: G, x: G, a: G, b: G, n: G) -> (List‹SymExpr›, G, G, G, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), t, x, a, b),
       _ =>
-        let (x, s) = read_sym_expr(stream);
-        let (rest, s2) = read_sym_exprs_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (e, t1, x1, a1, b1) = read_sym_expr(t, x, a, b);
+        let (rest, t2, x2, a2, b2) = read_sym_exprs_n(t1, x1, a1, b1, n - 1);
+        (store(ListNode.Cons(e, rest)), t2, x2, a2, b2),
     }
   }
 
-  fn read_sys_lookup(stream: ByteStream) -> (SysLookup, ByteStream) {
-    let (m, s) = read_sym_expr(stream);
-    let (args, s2) = read_sym_exprs(s);
-    (SysLookup.Mk(m, args), s2)
-  }
-  fn read_sys_lookups(stream: ByteStream) -> (List‹SysLookup›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_sys_lookups_n(s, n)
+  -- ==========================================================================
+  -- Circuit readers. Cursor m = META joins for the count/metadata fields.
+  -- ==========================================================================
+
+  fn read_sys_lookup(t: G, x: G, a: G, b: G, m: G) -> (SysLookup, G, G, G, G, G) {
+    let (mul, t1, x1, a1, b1) = read_sym_expr(t, x, a, b);
+    let (na, m1) = #read_vk_u32(m);
+    let (args, t2, x2, a2, b2) = read_sym_exprs_n(t1, x1, a1, b1, na);
+    (SysLookup.Mk(mul, args), t2, x2, a2, b2, m1)
   }
-  fn read_sys_lookups_n(stream: ByteStream, n: G) -> (List‹SysLookup›, ByteStream) {
+  fn read_sys_lookups_n(t: G, x: G, a: G, b: G, m: G, n: G) -> (List‹SysLookup›, G, G, G, G, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), t, x, a, b, m),
       _ =>
-        let (x, s) = read_sys_lookup(stream);
-        let (rest, s2) = read_sys_lookups_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (l, t1, x1, a1, b1, m1) = read_sys_lookup(t, x, a, b, m);
+        let (rest, t2, x2, a2, b2, m2) = read_sys_lookups_n(t1, x1, a1, b1, m1, n - 1);
+        (store(ListNode.Cons(l, rest)), t2, x2, a2, b2, m2),
     }
   }
 
-  fn read_sys_constraints(stream: ByteStream) -> (SysConstraints, ByteStream) {
-    let (zeros, s) = read_sym_exprs(stream);
-    let (sel_start, s1) = read_count(s);
-    let (sel_end, s2) = read_count(s1);
-    let (width, s3) = read_count(s2);
-    (SysConstraints.Mk(zeros, sel_start, sel_end, width), s3)
-  }
-
-  fn read_sys_air(stream: ByteStream) -> (SysAir, ByteStream) {
-    let (tag, s) = read_u32(stream);
+  fn read_sys_air(t: G, x: G, a: G, b: G, m: G) -> (SysAir, G, G, G, G, G) {
+    let (tag, t1) = #read_vk_tag(t);
     match tag {
-      0 => let (c, s1) = read_sys_constraints(s); (SysAir.Function(c), s1),
-      1 => let (w, s1) = read_count(s); (SysAir.Memory(SysMemory.Mk(w)), s1),
-      2 => (SysAir.Bytes1, s),
-      _ => (SysAir.Bytes2, s),
+      0 =>
+        let (nz, m1) = #read_vk_u32(m);
+        let (zeros, t2, x2, a2, b2) = read_sym_exprs_n(t1, x, a, b, nz);
+        let (ss, m2) = #read_vk_u32(m1);
+        let (se, m3) = #read_vk_u32(m2);
+        let (w, m4) = #read_vk_u32(m3);
+        (SysAir.Function(SysConstraints.Mk(zeros, ss, se, w)), t2, x2, a2, b2, m4),
+      1 => let (w, m1) = #read_vk_u32(m); (SysAir.Memory(SysMemory.Mk(w)), t1, x, a, b, m1),
+      2 => (SysAir.Bytes1, t1, x, a, b, m),
+      _ => (SysAir.Bytes2, t1, x, a, b, m),
     }
   }
 
-  fn read_sys_lookupair(stream: ByteStream) -> (SysLookupAir, ByteStream) {
-    let (inner, s) = read_sys_air(stream);
-    let (lookups, s1) = read_sys_lookups(s);
-    (SysLookupAir.Mk(inner, lookups), s1)
-  }
-
-  -- Besides the parsed circuit, also returns its 6 metadata words as raw u64
-  -- limbs — `observe_shape` feeds exactly these bytes into the challenger.
-  fn read_sys_circuit(stream: ByteStream) -> (SysCircuit, [U64; 6], ByteStream) {
-    let (air, s) = read_sys_lookupair(stream);
-    let (cc, s1) = read_u64(s);
-    let (md, s2) = read_u64(s1);
-    let (ph, s3) = read_u64(s2);
-    let (pw, s4) = read_u64(s3);
-    let (w1, s5) = read_u64(s4);
-    let (w2, s6) = read_u64(s5);
-    (SysCircuit.Mk(air, flatten_u64(cc), flatten_u64(md), flatten_u64(ph),
-                   flatten_u64(pw), flatten_u64(w1), flatten_u64(w2)),
-     [cc, md, ph, pw, w1, w2], s6)
+  -- One circuit record: 5 × u32 segment lengths, then the segments. Besides
+  -- the parsed circuit, also returns its 6 metadata words as u64 limbs —
+  -- `observe_shape` feeds exactly these bytes into the challenger. The end
+  -- asserts pin every segment to exact consumption, binding the header
+  -- lengths to the parsed structure.
+  fn read_sys_circuit(base: G) -> (SysCircuit, [U64; 6], G) {
+    let (lt, h1) = #read_vk_u32(base);
+    let (lx, h2) = #read_vk_u32(h1);
+    let (la, h3) = #read_vk_u32(h2);
+    let (lb, h4) = #read_vk_u32(h3);
+    let (lm, h5) = #read_vk_u32(h4);
+    let t0 = h5;
+    let x0 = t0 + lt;
+    let a0 = x0 + lx;
+    let b0 = a0 + la;
+    let m0 = b0 + lb;
+    let rend = m0 + lm;
+    let (air, t1, x1, a1, b1, m1) = read_sys_air(t0, x0, a0, b0, m0);
+    let (nl, m2) = #read_vk_u32(m1);
+    let (lookups, t2, x2, a2, b2, m3) = read_sys_lookups_n(t1, x1, a1, b1, m2, nl);
+    let (cc, ccl, m4) = #read_vk_u32_limb(m3);
+    let (md, mdl, m5) = #read_vk_u32_limb(m4);
+    let (ph, phl, m6) = #read_vk_u32_limb(m5);
+    let (pw, pwl, m7) = #read_vk_u32_limb(m6);
+    let (w1, w1l, m8) = #read_vk_u32_limb(m7);
+    let (w2, w2l, m9) = #read_vk_u32_limb(m8);
+    assert_eq!(t2, x0);
+    assert_eq!(x2, a0);
+    assert_eq!(a2, b0);
+    assert_eq!(b2, m0);
+    assert_eq!(m9, rend);
+    (SysCircuit.Mk(SysLookupAir.Mk(air, lookups), cc, md, ph, pw, w1, w2),
+     [ccl, mdl, phl, pwl, w1l, w2l], rend)
   }
   fn cons_shape6(l: [U64; 6], tail: List‹U64›) -> List‹U64› {
     store(ListNode.Cons(l[0], store(ListNode.Cons(l[1], store(ListNode.Cons(l[2],
     store(ListNode.Cons(l[3], store(ListNode.Cons(l[4], store(ListNode.Cons(l[5],
     tail))))))))))))
   }
-  -- Returns the circuits plus their shape limbs (`observe_shape` order: the
-  -- raw circuit-count word, then each circuit's 6 metadata words).
-  fn read_sys_circuits(stream: ByteStream) -> (List‹SysCircuit›, List‹U64›, ByteStream) {
-    let (nl, s) = read_u64(stream);
-    let (cs, limbs, s1) = read_sys_circuits_n(s, flatten_u64(nl));
-    (cs, store(ListNode.Cons(nl, limbs)), s1)
-  }
-  fn read_sys_circuits_n(stream: ByteStream, n: G) -> (List‹SysCircuit›, List‹U64›, ByteStream) {
+  -- Returns the circuits plus their shape limbs (`observe_shape` order: each
+  -- circuit's 6 metadata words; the count limb is consed by `read_system`).
+  fn read_sys_circuits_n(i: G, n: G) -> (List‹SysCircuit›, List‹U64›, G) {
     match n {
-      0 => (store(ListNode.Nil), store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), store(ListNode.Nil), i),
       _ =>
-        let (x, xl, s) = read_sys_circuit(stream);
-        let (rest, lrest, s2) = read_sys_circuits_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), cons_shape6(xl, lrest), s2),
+        let (x, xl, j) = read_sys_circuit(i);
+        let (rest, lrest, j2) = read_sys_circuits_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), cons_shape6(xl, lrest), j2),
     }
   }
 
-  -- `Option` tag is a single byte (bincode special-cases Option).
-  fn read_opt_commit(stream: ByteStream) -> (OptCommit, ByteStream) {
-    let (tag, s) = read_u8(stream);
-    match tag {
-      0 => (OptCommit.NoCommit, s),
-      _ => let (c, s1) = read_merkle_cap(s); (OptCommit.SomeCommit(c), s1),
-    }
-  }
-  fn read_opt_idx(stream: ByteStream) -> (OptIdx, ByteStream) {
-    let (tag, s) = read_u8(stream);
+  -- ==========================================================================
+  -- Trailer.
+  -- ==========================================================================
+
+  fn read_opt_commit(i: G) -> (OptCommit, G) {
+    let (tag, j) = #read_vk_u8(i);
     match tag {
-      0 => (OptIdx.NoIdx, s),
-      _ => let (i, s1) = read_count(s); (OptIdx.SomeIdx(i), s1),
+      0 => (OptCommit.NoCommit, j),
+      _ =>
+        let (n, j1) = #read_vk_u16(j);
+        let (c, j2) = read_vk_cap_n(j1, n);
+        (OptCommit.SomeCommit(c), j2),
     }
   }
-  fn read_opt_idx_list(stream: ByteStream) -> (List‹OptIdx›, ByteStream) {
-    let (n, s) = read_count(stream);
-    read_opt_idx_list_n(s, n)
-  }
-  fn read_opt_idx_list_n(stream: ByteStream, n: G) -> (List‹OptIdx›, ByteStream) {
+  -- One u16 per circuit; 0xFFFF is the None sentinel.
+  fn read_opt_idx_n(i: G, n: G) -> (List‹OptIdx›, G) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (store(ListNode.Nil), i),
       _ =>
-        let (x, s) = read_opt_idx(stream);
-        let (rest, s2) = read_opt_idx_list_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        let (v, j) = #read_vk_u16(i);
+        let (rest, j2) = read_opt_idx_n(j, n - 1);
+        match v {
+          65535 => (store(ListNode.Cons(OptIdx.NoIdx, rest)), j2),
+          _ => (store(ListNode.Cons(OptIdx.SomeIdx(v), rest)), j2),
+        },
     }
   }
 
-  -- The 7 protocol parameters, both as field counts (for the verifier logic)
-  -- and as raw u64 limbs (their LE bytes seed the challenger).
-  fn read_sys_params(stream: ByteStream) -> (SysParams, List‹U64›, ByteStream) {
-    let (l0, s0) = read_u64(stream);
-    let (l1, s1) = read_u64(s0);
-    let (l2, s2) = read_u64(s1);
-    let (l3, s3) = read_u64(s2);
-    let (l4, s4) = read_u64(s3);
-    let (l5, s5) = read_u64(s4);
-    let (l6, s6) = read_u64(s5);
-    (SysParams.Mk(flatten_u64(l0), flatten_u64(l1), flatten_u64(l2),
-                  flatten_u64(l3), flatten_u64(l4), flatten_u64(l5),
-                  flatten_u64(l6)),
+  -- The 7 protocol parameters, both as field values (for the verifier logic)
+  -- and as u64 limbs (their LE bytes seed the challenger).
+  fn read_sys_params(i: G) -> (SysParams, List‹U64›, G) {
+    let (p0, l0, j0) = #read_vk_u16_limb(i);
+    let (p1, l1, j1) = #read_vk_u16_limb(j0);
+    let (p2, l2, j2) = #read_vk_u16_limb(j1);
+    let (p3, l3, j3) = #read_vk_u16_limb(j2);
+    let (p4, l4, j4) = #read_vk_u16_limb(j3);
+    let (p5, l5, j5) = #read_vk_u16_limb(j4);
+    let (p6, l6, j6) = #read_vk_u16_limb(j5);
+    (SysParams.Mk(p0, p1, p2, p3, p4, p5, p6),
      store(ListNode.Cons(l0, store(ListNode.Cons(l1, store(ListNode.Cons(l2,
      store(ListNode.Cons(l3, store(ListNode.Cons(l4, store(ListNode.Cons(l5,
      store(ListNode.Cons(l6, store(ListNode.Nil))))))))))))))),
-     s6)
+     j6)
   }
 
-  -- Full `System<AiurCircuit>`.
-  fn read_system(stream: ByteStream) -> (Sys, ByteStream) {
-    let (params, plimbs, s) = read_sys_params(stream);
-    let (circuits, climbs, s1) = read_sys_circuits(s);
-    let (commit, s2) = read_opt_commit(s1);
-    let (indices, s3) = read_opt_idx_list(s2);
-    (Sys.Mk(params, list_concat(plimbs, climbs), circuits, commit, indices), s3)
+  -- Full `System<AiurCircuit>`, read from the channel-1 IO arena starting at
+  -- byte offset `i`. Returns the end offset; the entrypoint asserts full
+  -- consumption.
+  fn read_system(i: G) -> (Sys, G) {
+    let (params, plimbs, j) = read_sys_params(i);
+    let (n, nlimb, j1) = #read_vk_u16_limb(j);
+    let (circuits, climbs, j2) = read_sys_circuits_n(j1, n);
+    let (commit, j3) = read_opt_commit(j2);
+    let (indices, j4) = read_opt_idx_n(j3, n);
+    (Sys.Mk(params,
+            list_concat(plimbs, store(ListNode.Cons(nlimb, climbs))),
+            circuits, commit, indices),
+     j4)
   }
 ⟧
 
diff --git a/Ix/MultiStark/Tests.lean b/Ix/MultiStark/Tests.lean
index 6d26ed434..437df4d78 100644
--- a/Ix/MultiStark/Tests.lean
+++ b/Ix/MultiStark/Tests.lean
@@ -23,30 +23,25 @@ namespace MultiStark
 
 def tests := ⟦
   -- ==========================================================================
-  -- Non-native Goldilocks byte arithmetic (vs `gl_ops_ref`).
+  -- Native Goldilocks arithmetic (vs `gl_ops_ref`; reference vectors kept as
+  -- their canonical LE bytes and folded with `gl_val`, which is injective on
+  -- canonical bytes).
   -- ==========================================================================
   fn assert_g8(x: Goldilocks, e: Goldilocks) -> G {
-    assert_eq!(to_field(x[0]), to_field(e[0]));
-    assert_eq!(to_field(x[1]), to_field(e[1]));
-    assert_eq!(to_field(x[2]), to_field(e[2]));
-    assert_eq!(to_field(x[3]), to_field(e[3]));
-    assert_eq!(to_field(x[4]), to_field(e[4]));
-    assert_eq!(to_field(x[5]), to_field(e[5]));
-    assert_eq!(to_field(x[6]), to_field(e[6]));
-    assert_eq!(to_field(x[7]), to_field(e[7]));
+    assert_eq!(x, e);
     1
   }
   pub fn gl_addsub_test() -> G {
-    let a = [16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]; -- 0xFEDCBA9876543210
-    let b = [240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]; -- 0x123456789ABCDEF0
-    assert_eq!(assert_g8(gl_add(a, b), [255u8, 16u8, 17u8, 17u8, 18u8, 17u8, 17u8, 17u8]), 1);
-    assert_eq!(assert_g8(gl_sub(a, b), [32u8, 83u8, 151u8, 219u8, 31u8, 100u8, 168u8, 236u8]), 1);
-    assert_eq!(assert_g8(gl_sub(b, a), [225u8, 172u8, 104u8, 36u8, 223u8, 155u8, 87u8, 19u8]), 1);
+    let a = gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210
+    let b = gl_val([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0
+    assert_eq!(assert_g8(gl_add(a, b), gl_val([255u8, 16u8, 17u8, 17u8, 18u8, 17u8, 17u8, 17u8])), 1);
+    assert_eq!(assert_g8(gl_sub(a, b), gl_val([32u8, 83u8, 151u8, 219u8, 31u8, 100u8, 168u8, 236u8])), 1);
+    assert_eq!(assert_g8(gl_sub(b, a), gl_val([225u8, 172u8, 104u8, 36u8, 223u8, 155u8, 87u8, 19u8])), 1);
     -- edge: (p-1) + 5 ≡ 4 ; 5 - (p-1) ≡ 6
-    let pm1 = [0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]; -- 0xFFFFFFFF00000000
-    let five = [5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
-    assert_eq!(assert_g8(gl_add(pm1, five), [4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), 1);
-    assert_eq!(assert_g8(gl_sub(five, pm1), [6u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), 1);
+    let pm1 = gl_val([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]); -- 0xFFFFFFFF00000000
+    let five = gl_val([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    assert_eq!(assert_g8(gl_add(pm1, five), gl_val([4u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1);
+    assert_eq!(assert_g8(gl_sub(five, pm1), gl_val([6u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])), 1);
     1
   }
 
@@ -56,15 +51,15 @@ def tests := ⟦
     1
   }
   pub fn gl_muldiv_test() -> G {
-    let a = [16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]; -- 0xFEDCBA9876543210
-    let b = [240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]; -- 0x123456789ABCDEF0
-    assert_eq!(assert_g8(gl_mul(a, b), [212u8, 186u8, 123u8, 108u8, 31u8, 253u8, 234u8, 250u8]), 1);
-    assert_eq!(assert_g8(gl_inverse(a), [97u8, 29u8, 109u8, 46u8, 183u8, 100u8, 8u8, 102u8]), 1);
-    assert_eq!(assert_g8(gl_div(a, b), [63u8, 59u8, 61u8, 54u8, 46u8, 255u8, 29u8, 186u8]), 1);
+    let a = gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]); -- 0xFEDCBA9876543210
+    let b = gl_val([240u8, 222u8, 188u8, 154u8, 120u8, 86u8, 52u8, 18u8]); -- 0x123456789ABCDEF0
+    assert_eq!(assert_g8(gl_mul(a, b), gl_val([212u8, 186u8, 123u8, 108u8, 31u8, 253u8, 234u8, 250u8])), 1);
+    assert_eq!(assert_g8(gl_inverse(a), gl_val([97u8, 29u8, 109u8, 46u8, 183u8, 100u8, 8u8, 102u8])), 1);
+    assert_eq!(assert_g8(gl_div(a, b), gl_val([63u8, 59u8, 61u8, 54u8, 46u8, 255u8, 29u8, 186u8])), 1);
     -- edge: (p-1)·5 ≡ p-5
-    let pm1 = [0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8];
-    let five = [5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
-    assert_eq!(assert_g8(gl_mul(pm1, five), [252u8, 255u8, 255u8, 255u8, 254u8, 255u8, 255u8, 255u8]), 1);
+    let pm1 = gl_val([0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8]);
+    let five = gl_val([5u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    assert_eq!(assert_g8(gl_mul(pm1, five), gl_val([252u8, 255u8, 255u8, 255u8, 254u8, 255u8, 255u8, 255u8])), 1);
     -- a·a⁻¹ = 1 and b·b⁻¹ = 1
     assert_eq!(assert_g8(gl_mul(a, gl_inverse(a)), gl_one()), 1);
     assert_eq!(assert_g8(gl_mul(b, gl_inverse(b)), gl_one()), 1);
@@ -72,22 +67,22 @@ def tests := ⟦
   }
   pub fn eg_ops_test() -> G {
     -- e0 = (0xFEDCBA9876543210, 0x0123456789ABCDEF), e1 = (0x1111111122222222, 0x3333333344444444)
-    let e0 = [[16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8],
-              [239u8, 205u8, 171u8, 137u8, 103u8, 69u8, 35u8, 1u8]];
-    let e1 = [[34u8, 34u8, 34u8, 34u8, 17u8, 17u8, 17u8, 17u8],
-              [68u8, 68u8, 68u8, 68u8, 51u8, 51u8, 51u8, 51u8]];
+    let e0 = [gl_val([16u8, 50u8, 84u8, 118u8, 152u8, 186u8, 220u8, 254u8]),
+              gl_val([239u8, 205u8, 171u8, 137u8, 103u8, 69u8, 35u8, 1u8])];
+    let e1 = [gl_val([34u8, 34u8, 34u8, 34u8, 17u8, 17u8, 17u8, 17u8]),
+              gl_val([68u8, 68u8, 68u8, 68u8, 51u8, 51u8, 51u8, 51u8])];
     assert_eq!(assert_eg(eg_add(e0, e1),
-      [49u8, 84u8, 118u8, 152u8, 170u8, 203u8, 237u8, 15u8],
-      [51u8, 18u8, 240u8, 205u8, 154u8, 120u8, 86u8, 52u8]), 1);
+      gl_val([49u8, 84u8, 118u8, 152u8, 170u8, 203u8, 237u8, 15u8]),
+      gl_val([51u8, 18u8, 240u8, 205u8, 154u8, 120u8, 86u8, 52u8])), 1);
     assert_eq!(assert_eg(eg_mul(e0, e1),
-      [10u8, 238u8, 162u8, 36u8, 224u8, 127u8, 182u8, 134u8],
-      [215u8, 234u8, 152u8, 224u8, 219u8, 254u8, 32u8, 67u8]), 1);
+      gl_val([10u8, 238u8, 162u8, 36u8, 224u8, 127u8, 182u8, 134u8]),
+      gl_val([215u8, 234u8, 152u8, 224u8, 219u8, 254u8, 32u8, 67u8])), 1);
     assert_eq!(assert_eg(eg_inverse(e0),
-      [221u8, 238u8, 29u8, 131u8, 179u8, 89u8, 214u8, 216u8],
-      [114u8, 99u8, 206u8, 108u8, 15u8, 88u8, 161u8, 246u8]), 1);
+      gl_val([221u8, 238u8, 29u8, 131u8, 179u8, 89u8, 214u8, 216u8]),
+      gl_val([114u8, 99u8, 206u8, 108u8, 15u8, 88u8, 161u8, 246u8])), 1);
     assert_eq!(assert_eg(eg_div(e0, e1),
-      [42u8, 59u8, 64u8, 77u8, 226u8, 214u8, 95u8, 63u8],
-      [200u8, 46u8, 148u8, 147u8, 124u8, 180u8, 248u8, 140u8]), 1);
+      gl_val([42u8, 59u8, 64u8, 77u8, 226u8, 214u8, 95u8, 63u8]),
+      gl_val([200u8, 46u8, 148u8, 147u8, 124u8, 180u8, 248u8, 140u8])), 1);
     -- e0 · e0⁻¹ = 1
     assert_eq!(assert_eg(eg_mul(e0, eg_inverse(e0)), gl_one(), gl_zero()), 1);
     1
@@ -121,16 +116,16 @@ def tests := ⟦
     -- α_pcs (output empty ⇒ flush), then α_fri (CONSECUTIVE ⇒ thread output).
     let (apcs, input, o1) = pcs_sample_ext(input, store(ListNode.Nil));
     let (afri, input, o2) = pcs_sample_ext(input, o1);
-    assert_eq!(limb_to_field(apcs[0]), 17795849114622667264);
-    assert_eq!(limb_to_field(apcs[1]), 4116843485681689527);
-    assert_eq!(limb_to_field(afri[0]), 11768399386651893439);
-    assert_eq!(limb_to_field(afri[1]), 10948618071942561750);
+    assert_eq!(apcs[0], 17795849114622667264);
+    assert_eq!(apcs[1], 4116843485681689527);
+    assert_eq!(afri[0], 11768399386651893439);
+    assert_eq!(afri[1], 10948618071942561750);
     -- observe commit (clears output), sample β.
     let v2 = [239u8, 190u8, 173u8, 222u8, 0u8, 0u8, 0u8, 0u8]; -- 0x00000000deadbeef
     let (input, _oc) = ch_observe_val(input, v2);
     let (beta, input, _ob) = pcs_sample_ext(input, store(ListNode.Nil));
-    assert_eq!(limb_to_field(beta[0]), 12096272534537655203);
-    assert_eq!(limb_to_field(beta[1]), 11431251745744402868);
+    assert_eq!(beta[0], 12096272534537655203);
+    assert_eq!(beta[1], 11431251745744402868);
     -- observe final_poly coeff + log_arity (each a Val), then sample the index.
     let v3 = [4u8, 3u8, 2u8, 1u8, 13u8, 12u8, 11u8, 10u8]; -- 0x0a0b0c0d01020304
     let v4 = [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];     -- 0x0000000000000002
@@ -150,15 +145,15 @@ def tests := ⟦
   pub fn fri_fold_test() -> G {
     let index_bits = store(ListNode.Cons(1, store(ListNode.Cons(0,
                        store(ListNode.Cons(1, store(ListNode.Nil)))))));
-    let e0 = [[17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8],
-              [34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8]];
-    let e1 = [[51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8],
-              [68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8]];
-    let beta = [[85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8],
-                [102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8]];
+    let e0 = [gl_val([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]),
+              gl_val([34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8])];
+    let e1 = [gl_val([51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8]),
+              gl_val([68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8, 68u8])];
+    let beta = [gl_val([85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8, 85u8]),
+                gl_val([102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8, 102u8])];
     let folded = fri_fold2(index_bits, 3, beta, e0, e1);
-    assert_eq!(limb_to_field(folded[0]), 9349172584842537206);
-    assert_eq!(limb_to_field(folded[1]), 984486879173118962);
+    assert_eq!(folded[0], 9349172584842537206);
+    assert_eq!(folded[1], 984486879173118962);
     1
   }
 
@@ -168,25 +163,25 @@ def tests := ⟦
     let index_bits = store(ListNode.Cons(1, store(ListNode.Cons(0,
                        store(ListNode.Cons(1, store(ListNode.Nil)))))));
     let x = ro_x(index_bits, 3);
-    assert_eq!(limb_to_field(x), 117440512);
-    let z = [[154u8, 120u8, 86u8, 52u8, 18u8, 0u8, 0u8, 0u8],
-             [1u8, 239u8, 205u8, 171u8, 0u8, 0u8, 0u8, 0u8]];
-    let alpha = [[17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8],
-                 [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]];
-    let px0 = [11u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
-    let px1 = [22u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
-    let px2 = [33u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
+    assert_eq!(x, 117440512);
+    let z = [gl_val([154u8, 120u8, 86u8, 52u8, 18u8, 0u8, 0u8, 0u8]),
+             gl_val([1u8, 239u8, 205u8, 171u8, 0u8, 0u8, 0u8, 0u8])];
+    let alpha = [gl_val([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]),
+                 gl_val([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
+    let px0 = gl_val([11u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let px1 = gl_val([22u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+    let px2 = gl_val([33u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
     let p_x = store(ListNode.Cons(px0, store(ListNode.Cons(px1,
                 store(ListNode.Cons(px2, store(ListNode.Nil)))))));
-    let pz0 = [[100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]];
-    let pz1 = [[200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]];
-    let pz2 = [[44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], [3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]];
+    let pz0 = [gl_val([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), gl_val([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
+    let pz1 = [gl_val([200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), gl_val([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
+    let pz2 = [gl_val([44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), gl_val([3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
     let p_z = store(ListNode.Cons(pz0, store(ListNode.Cons(pz1,
                 store(ListNode.Cons(pz2, store(ListNode.Nil)))))));
     let q = eg_inverse(eg_sub(z, [x, gl_zero()]));
     let (ro, _ap) = ro_fold(p_x, p_z, q, alpha, [gl_zero(), gl_zero()], [gl_one(), gl_zero()]);
-    assert_eq!(limb_to_field(ro[0]), 7130765474285082575);
-    assert_eq!(limb_to_field(ro[1]), 12254464995725315436);
+    assert_eq!(ro[0], 7130765474285082575);
+    assert_eq!(ro[1], 12254464995725315436);
     1
   }
 
@@ -286,6 +281,109 @@ def tests := ⟦
     assert_eq!(mmcs_verify(cap, bad_rows, lhs, ibits, proof, 3), 0);
     1
   }
+
+  -- Differential test for the lane-granular leaf hasher: `b3_lanes` must
+  -- agree with byte-granular `blake3` over the lanes' LE bytes at every
+  -- structural boundary — empty input, partial block, exact block (8 lanes),
+  -- block + 1, exact chunk (128 lanes), chunk + 1, a 2-chunk input with
+  -- varied bytes, and a 4-chunk input (deeper layer fold). Lane bytes vary
+  -- with the index so lane- or word-order bugs change the digest.
+  fn lane_test_row(n: G) -> List‹U64› {
+    match n {
+      0 => store(ListNode.Nil),
+      _ =>
+        -- n mod 256, valid for n ≤ 511 (largest size used below is 500).
+        let lo = u8_from_field_unsafe(n - 256 * u32_less_than(255, n));
+        store(ListNode.Cons([lo, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8],
+                            lane_test_row(n - 1))),
+    }
+  }
+  fn lane_hash_check(n: G) -> G {
+    let row = lane_test_row(n);
+    digest_eq(b3_to_digest(b3_lanes(row)),
+              b3_to_digest(blake3(b3_row_onto(row, store(ListNode.Nil)))))
+  }
+  pub fn lane_hash_test() -> G {
+    lane_hash_check(0) * lane_hash_check(1) * lane_hash_check(7)
+      * lane_hash_check(8) * lane_hash_check(9) * lane_hash_check(127)
+      * lane_hash_check(128) * lane_hash_check(129) * lane_hash_check(255)
+      * lane_hash_check(500)
+  }
+
+  -- Differential test for the rows-walking leaf hasher: `b3_rows` over the
+  -- selected rows must agree with the concat + canon reference
+  -- (`mmcs_hash_row(canon_lanes(concat_at(...)))`) across shapes: all/none/
+  -- some rows selected, an empty row mixed in, exact-block totals, and a
+  -- multi-chunk total (layer fold). Rows reuse `lane_test_row`'s varied
+  -- bytes.
+  fn rows_test_rows(spec: List‹G›) -> List‹List‹U64›› {
+    match load(spec) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(n, rest) => store(ListNode.Cons(lane_test_row(n), rows_test_rows(rest))),
+    }
+  }
+  fn rows_hash_check(spec: List‹G›, lhs: List‹G›, target: G) -> G {
+    let rows = rows_test_rows(spec);
+    digest_eq(b3_to_digest(b3_rows(select_rows(rows, lhs, target))),
+              mmcs_hash_row(canon_lanes(concat_at(rows, lhs, target))))
+  }
+  fn g1(a: G) -> List‹G› { store(ListNode.Cons(a, store(ListNode.Nil))) }
+  fn g2(a: G, b: G) -> List‹G› { store(ListNode.Cons(a, g1(b))) }
+  fn g3(a: G, b: G, c: G) -> List‹G› { store(ListNode.Cons(a, g2(b, c))) }
+  pub fn rows_hash_test() -> G {
+    rows_hash_check(g3(3, 5, 2), g3(7, 7, 7), 7)
+      * rows_hash_check(g3(3, 5, 2), g3(7, 7, 7), 5)
+      * rows_hash_check(g3(3, 0, 5), g3(7, 7, 7), 7)
+      * rows_hash_check(g1(8), g1(4), 4)
+      * rows_hash_check(g2(130, 130), g2(9, 9), 9)
+      * rows_hash_check(g3(5, 9, 3), g3(2, 9, 2), 2)
+  }
+
+  -- Differential test for the IO-slice hasher: `b3_io` over the bytes the
+  -- test writes to a channel arena must agree with byte-granular `blake3`
+  -- over the same bytes, at the same structural boundaries as the lane test
+  -- (empty, partial/exact/over block, partial/exact/over chunk, multi-chunk
+  -- with layer fold). Uses `io_write` to populate channel 9 (unused by any
+  -- production stream), with each length's bytes at a distinct offset.
+  fn io_test_fill(n: G, off: G, b: G) -> G {
+    match n {
+      0 => off,
+      _ =>
+        -- `b` cycles 255 → 0 → 255 → …, so any length gets varied,
+        -- always-in-range bytes.
+        io_write(9, [b]);
+        let z = eq_zero(b);
+        io_test_fill(n - 1, off + 1, ((b - 1) * (1 - z)) + (255 * z)),
+    }
+  }
+  fn io_test_bytes(n: G, off: G) -> ByteStream {
+    match n {
+      0 => store(ListNode.Nil),
+      _ =>
+        let [b] = io_read(9, off, 1);
+        store(ListNode.Cons(u8_from_field_unsafe(b), io_test_bytes(n - 1, off + 1))),
+    }
+  }
+  fn io_hash_check(n: G, off: G) -> (G, G) {
+    let stop = io_test_fill(n, off, 173);
+    let a = b3_io(9, off, n);
+    let b = blake3(io_test_bytes(n, off));
+    (digest_eq(b3_to_digest(a), b3_to_digest(b)), stop)
+  }
+  pub fn io_hash_test() -> G {
+    let (r0, o0) = io_hash_check(0, 0);
+    let (r1, o1) = io_hash_check(1, o0);
+    let (r2, o2) = io_hash_check(7, o1);
+    let (r3, o3) = io_hash_check(8, o2);
+    let (r4, o4) = io_hash_check(63, o3);
+    let (r5, o5) = io_hash_check(64, o4);
+    let (r6, o6) = io_hash_check(65, o5);
+    let (r7, o7) = io_hash_check(1023, o6);
+    let (r8, o8) = io_hash_check(1024, o7);
+    let (r9, o9) = io_hash_check(1025, o8);
+    let (r10, _o10) = io_hash_check(2500, o9);
+    r0 * r1 * r2 * r3 * r4 * r5 * r6 * r7 * r8 * r9 * r10
+  }
 ⟧
 
 end MultiStark
diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean
index 0892cde14..6c1627211 100644
--- a/Ix/MultiStark/Verifier.lean
+++ b/Ix/MultiStark/Verifier.lean
@@ -67,7 +67,7 @@ def verifier := ⟦
   -- An extension element `[c0, c1]` (`= c0 + c1·X`) is zero iff both Goldilocks
   -- coefficients are zero. (`read_ext` already reduced the limbs mod p.)
   fn ext_is_zero(e: Ext) -> G {
-    gl_is_zero(e[0]) * gl_is_zero(e[1])
+    eq_zero(e[0]) * eq_zero(e[1])
   }
 
   -- 1 iff the LAST element of the accumulator list is the zero extension
@@ -168,12 +168,11 @@ def verifier := ⟦
   -- (the `log2_ceil(p) = 64` mask is a no-op for Goldilocks); if the raw value
   -- is ≥ p (probability ≈ 2⁻³²), DISCARD it and draw the next 8 bytes — a
   -- rejected draw consumes challenger bytes, shifting every later sample,
-  -- exactly as in the reference. `raw < p` ⟺ `sub8(raw, p)` borrows. The
-  -- accepted limb is canonical (< p) by construction.
+  -- exactly as in the reference. `gl_lt_p` decides `raw < p`; the accepted
+  -- limb is canonical (< p) by construction.
   fn ch_sample_field(input: ByteStream, output: ByteStream) -> ([U8; 8], ByteStream, ByteStream) {
     let (raw, i1, o1) = ch_sample8(input, output);
-    let (_d, borrow) = sub8(raw, gl_p());
-    match borrow {
+    match gl_lt_p(raw) {
       1 => (raw, i1, o1),
       _ => ch_sample_field(i1, o1),
     }
@@ -235,13 +234,15 @@ def verifier := ⟦
   fn snoc_cap(input: ByteStream, cap: MerkleCap) -> ByteStream {
     list_concat(input, cap_onto(cap, store(ListNode.Nil)))
   }
-  -- Append (observe) the intermediate accumulators, in order — each an
-  -- `observe_algebra_element`: two canonical 8-LE-byte limbs. (`read_ext`
+  -- The intermediate accumulators as a prepend-built stream, in order — each
+  -- an `observe_algebra_element`: two canonical 8-LE-byte limbs. (`read_ext`
   -- reduced the limbs mod p, matching `as_canonical_u64` serialization.)
-  fn snoc_accs(input: ByteStream, accs: List‹Ext›) -> ByteStream {
+  -- Prepend-composed so observing all of them is one `list_concat`, not a
+  -- per-element re-walk of the input buffer.
+  fn accs_onto(accs: List‹Ext›, tail: ByteStream) -> ByteStream {
     match load(accs) {
-      ListNode.Nil => input,
-      ListNode.Cons(e, rest) => snoc_accs(snoc_b8(snoc_b8(input, e[0]), e[1]), rest),
+      ListNode.Nil => tail,
+      ListNode.Cons(e, rest) => b8_onto(gl_to_bytes(e[0]), b8_onto(gl_to_bytes(e[1]), accs_onto(rest, tail))),
     }
   }
 
@@ -268,7 +269,7 @@ def verifier := ⟦
   fn pcs_sample_ext(input: ByteStream, output: ByteStream)
       -> (Ext, ByteStream, ByteStream) {
     let (c0, c1, i1, o1) = ch_sample_ext(input, output);
-    ([gl_reduce(c0), gl_reduce(c1)], i1, o1)
+    ([gl_val(c0), gl_val(c1)], i1, o1)
   }
 
   -- Append a claim's values (each `Val` as 8 LE bytes) onto `tail`, in order.
@@ -340,17 +341,28 @@ def verifier := ⟦
   -- (Phase 4+) continues observing into. The leftover `output` after the ζ
   -- sample is discarded — the next challenger op is an observe (of the opened
   -- values), which clears `output` anyway.
-  fn fiat_shamir(tlimbs: List‹U64›, prep: MerkleCap, s1: MerkleCap, s2: MerkleCap,
+  -- Each activation bit as an observed `Val` (8 LE bytes, 0 or 1).
+  fn active_onto(active: List‹G›, tail: ByteStream) -> ByteStream {
+    match load(active) {
+      ListNode.Nil => tail,
+      ListNode.Cons(b, rest) =>
+        b8_onto([u8_from_field_unsafe(b), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+                active_onto(rest, tail)),
+    }
+  }
+
+  fn fiat_shamir(tlimbs: List‹U64›, active: List‹G›, prep: MerkleCap, s1: MerkleCap, s2: MerkleCap,
       q: MerkleCap, lds: List‹U8›, claims: List‹List‹U64››, accs: List‹Ext›)
       -> (Ext, Ext, Ext, Ext, ByteStream) {
     -- Initial transcript, front-to-back: seed tag, parameter + shape words
-    -- (`tlimbs`, from the verifying key), prep, stage_1, log_degrees, claims.
-    -- Built inner-to-outer with the prepend helpers so the result is in
-    -- forward (observation) order.
+    -- (`tlimbs`, from the verifying key), the activation bitmap, prep,
+    -- stage_1, log_degrees, claims. Built inner-to-outer with the prepend
+    -- helpers so the result is in forward (observation) order.
     let input = claims_onto(claims, store(ListNode.Nil));
     let input = log_degrees_onto(lds, input);
     let input = cap_onto(s1, input);
     let input = cap_onto(prep, input);
+    let input = active_onto(active, input);
     let input = limbs_onto(tlimbs, input);
     let input = seed_tag_onto(input);
     -- sample lookup challenge, then observe it back (append)
@@ -363,17 +375,17 @@ def verifier := ⟦
     let input = snoc_cap(input, s2);
     -- observe the intermediate accumulators (public values entering the
     -- constraints; α and ζ must depend on them directly)
-    let input = snoc_accs(input, accs);
+    let input = list_concat(input, accs_onto(accs, store(ListNode.Nil)));
     -- sample constraint challenge α (not observed)
     let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil));
     -- observe quotient commitment
     let input = snoc_cap(input, q);
     -- sample out-of-domain point ζ; keep the resulting `input` for the PCS phase
     let (z0, z1, zinput, _oz) = ch_sample_ext(input, store(ListNode.Nil));
-    ([gl_reduce(l0), gl_reduce(l1)],
-     [gl_reduce(f0), gl_reduce(f1)],
-     [gl_reduce(a0), gl_reduce(a1)],
-     [gl_reduce(z0), gl_reduce(z1)],
+    ([gl_val(l0), gl_val(l1)],
+     [gl_val(f0), gl_val(f1)],
+     [gl_val(a0), gl_val(a1)],
+     [gl_val(z0), gl_val(z1)],
      zinput)
   }
 
@@ -393,48 +405,48 @@ def verifier := ⟦
 
   -- `two_adic_generator(bits)` — a primitive 2^bits root of unity in Goldilocks
   -- (`Plonky3/goldilocks/src/goldilocks.rs::TWO_ADIC_GENERATORS`).
-  fn two_adic_gen(bits: G) -> [U8; 8] {
+  fn two_adic_gen(bits: G) -> Goldilocks {
     match bits {
-      0  => [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-      1  => [0u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 255u8],
-      2  => [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8, 0u8],
-      3  => [1u8, 0u8, 0u8, 255u8, 254u8, 255u8, 255u8, 255u8],
-      4  => [1u8, 0u8, 0u8, 0u8, 255u8, 255u8, 255u8, 239u8],
-      5  => [0u8, 192u8, 255u8, 255u8, 255u8, 63u8, 0u8, 0u8],
-      6  => [0u8, 0u8, 0u8, 0u8, 128u8, 0u8, 0u8, 0u8],
-      7  => [1u8, 0u8, 0u8, 8u8, 255u8, 7u8, 0u8, 248u8],
-      8  => [102u8, 169u8, 12u8, 230u8, 60u8, 20u8, 121u8, 191u8],
-      9  => [78u8, 31u8, 65u8, 92u8, 42u8, 208u8, 5u8, 25u8],
-      10 => [114u8, 217u8, 254u8, 139u8, 215u8, 42u8, 143u8, 157u8],
-      11 => [207u8, 200u8, 161u8, 29u8, 128u8, 180u8, 83u8, 6u8],
-      12 => [182u8, 252u8, 157u8, 149u8, 153u8, 81u8, 195u8, 242u8],
-      13 => [151u8, 121u8, 209u8, 53u8, 35u8, 239u8, 68u8, 21u8],
-      14 => [226u8, 161u8, 187u8, 16u8, 147u8, 9u8, 238u8, 224u8],
-      15 => [172u8, 186u8, 6u8, 35u8, 254u8, 207u8, 178u8, 246u8],
-      16 => [14u8, 69u8, 121u8, 191u8, 48u8, 150u8, 223u8, 84u8],
-      17 => [14u8, 138u8, 61u8, 170u8, 232u8, 166u8, 208u8, 171u8],
-      18 => [172u8, 190u8, 249u8, 5u8, 123u8, 26u8, 40u8, 129u8],
-      19 => [2u8, 51u8, 170u8, 140u8, 107u8, 28u8, 212u8, 251u8],
-      20 => [109u8, 231u8, 147u8, 94u8, 205u8, 46u8, 186u8, 48u8],
-      21 => [84u8, 38u8, 50u8, 50u8, 245u8, 174u8, 2u8, 245u8],
-      22 => [181u8, 70u8, 114u8, 230u8, 173u8, 24u8, 42u8, 75u8],
-      23 => [139u8, 201u8, 251u8, 54u8, 19u8, 90u8, 157u8, 234u8],
-      24 => [113u8, 225u8, 7u8, 195u8, 49u8, 204u8, 205u8, 134u8],
-      25 => [216u8, 239u8, 207u8, 110u8, 151u8, 245u8, 186u8, 75u8],
-      26 => [134u8, 226u8, 214u8, 120u8, 91u8, 208u8, 65u8, 237u8],
-      27 => [29u8, 23u8, 90u8, 145u8, 216u8, 141u8, 215u8, 16u8],
-      28 => [133u8, 68u8, 74u8, 0u8, 0u8, 149u8, 4u8, 89u8],
-      29 => [102u8, 38u8, 109u8, 164u8, 59u8, 201u8, 168u8, 223u8],
-      30 => [69u8, 8u8, 106u8, 184u8, 9u8, 208u8, 155u8, 126u8],
-      31 => [89u8, 230u8, 136u8, 85u8, 117u8, 127u8, 10u8, 64u8],
-      _  => [140u8, 135u8, 88u8, 218u8, 220u8, 41u8, 86u8, 24u8],
+      0  => 1,
+      1  => 18446744069414584320,
+      2  => 281474976710656,
+      3  => 18446744069397807105,
+      4  => 17293822564807737345,
+      5  => 70368744161280,
+      6  => 549755813888,
+      7  => 17870292113338400769,
+      8  => 13797081185216407910,
+      9  => 1803076106186727246,
+      10 => 11353340290879379826,
+      11 => 455906449640507599,
+      12 => 17492915097719143606,
+      13 => 1532612707718625687,
+      14 => 16207902636198568418,
+      15 => 17776499369601055404,
+      16 => 6115771955107415310,
+      17 => 12380578893860276750,
+      18 => 9306717745644682924,
+      19 => 18146160046829613826,
+      20 => 3511170319078647661,
+      21 => 17654865857378133588,
+      22 => 5416168637041100469,
+      23 => 16905767614792059275,
+      24 => 9713644485405565297,
+      25 => 5456943929260765144,
+      26 => 17096174751763063430,
+      27 => 1213594585890690845,
+      28 => 6414415596519834757,
+      29 => 16116352524544190054,
+      30 => 9123114210336311365,
+      31 => 4614640910117430873,
+      _  => 1753635133440165772,
     }
   }
 
   -- Vanishing polynomial of the trace domain (shift = 1, size 2^L) at point ζ:
   -- `Z_H(ζ) = ζ^(2^L) - 1`.
   fn trace_vanishing(zeta: Ext, l: G) -> Ext {
-    eg_sub(ext_exp_pow2(zeta, l), [gl_one(), gl_zero()])
+    eg_sub(ext_exp_pow2(zeta, l), [1, 0])
   }
 
   -- Lagrange selectors at ζ for the trace domain (shift = 1), mirroring
@@ -447,9 +459,9 @@ def verifier := ⟦
   fn trace_selectors(zeta: Ext, l: G) -> (Ext, Ext, Ext, Ext) {
     let zh = trace_vanishing(zeta, l);
     let ginv = gl_inverse(two_adic_gen(l));
-    let is_first = eg_div(zh, eg_sub(zeta, [gl_one(), gl_zero()]));
-    let is_last = eg_div(zh, eg_sub(zeta, [ginv, gl_zero()]));
-    let is_trans = eg_sub(zeta, [ginv, gl_zero()]);
+    let is_first = eg_div(zh, eg_sub(zeta, [1, 0]));
+    let is_last = eg_div(zh, eg_sub(zeta, [ginv, 0]));
+    let is_trans = eg_sub(zeta, [ginv, 0]);
     let inv_van = eg_inverse(zh);
     (is_first, is_last, is_trans, inv_van)
   }
@@ -462,7 +474,7 @@ def verifier := ⟦
   -- failed check, exactly as the Rust verifier returns `Err`.
   fn verify(proof: Proof) -> G {
     match proof {
-      Proof.Mk(_commitments, accs, _log_degrees, _opening,
+      Proof.Mk(_active, _commitments, accs, _log_degrees, _opening,
                _quotient, _preprocessed, stage_1, stage_2) =>
         -- Step 1 (shape, system-independent): the per-round opened-value lists
         -- and the accumulator list all have the same length = the circuit count.
@@ -505,7 +517,7 @@ def verifier := ⟦
   -- Reconstruct an extension element from its two opened base coordinates,
   -- `from_ext_basis([c0, c1]) = c0 + c1·X` (the ExtVal basis is `[1, X]`).
   fn from_ext_basis(c0: Ext, c1: Ext) -> Ext {
-    eg_add(c0, eg_mul(c1, [gl_zero(), gl_one()]))
+    eg_add(c0, eg_mul(c1, [0, 1]))
   }
 
   -- A stage-2 / quotient opened row arrives as `stage_2_width·2` extension
@@ -530,19 +542,19 @@ def verifier := ⟦
         match entry {
           SysEntry.Main(_o) => list_lookup(main, idx),
           SysEntry.Preprocessed(_o) => list_lookup(prep, idx),
-          SysEntry.Stage2(_o) => [gl_zero(), gl_zero()],
-          SysEntry.Public => [gl_zero(), gl_zero()],
-          SysEntry.Stage2Public => [gl_zero(), gl_zero()],
-          SysEntry.Challenge => [gl_zero(), gl_zero()],
+          SysEntry.Stage2(_o) => [0, 0],
+          SysEntry.Public => [0, 0],
+          SysEntry.Stage2Public => [0, 0],
+          SysEntry.Challenge => [0, 0],
         },
-      SymExpr.IsFirstRow => [gl_zero(), gl_zero()],
-      SymExpr.IsLastRow => [gl_zero(), gl_zero()],
-      SymExpr.IsTransition => [gl_zero(), gl_zero()],
-      SymExpr.Const(c) => [c, gl_zero()],
-      SymExpr.Add(x, y, _d) => eg_add(eval_sym(load(x), main, prep), eval_sym(load(y), main, prep)),
-      SymExpr.Sub(x, y, _d) => eg_sub(eval_sym(load(x), main, prep), eval_sym(load(y), main, prep)),
-      SymExpr.Neg(x, _d) => eg_neg(eval_sym(load(x), main, prep)),
-      SymExpr.Mul(x, y, _d) => eg_mul(eval_sym(load(x), main, prep), eval_sym(load(y), main, prep)),
+      SymExpr.IsFirstRow => [0, 0],
+      SymExpr.IsLastRow => [0, 0],
+      SymExpr.IsTransition => [0, 0],
+      SymExpr.Const(c) => [c, 0],
+      SymExpr.Add(x, y) => eg_add(eval_sym(load(x), main, prep), eval_sym(load(y), main, prep)),
+      SymExpr.Sub(x, y) => eg_sub(eval_sym(load(x), main, prep), eval_sym(load(y), main, prep)),
+      SymExpr.Neg(x) => eg_neg(eval_sym(load(x), main, prep)),
+      SymExpr.Mul(x, y) => eg_mul(eval_sym(load(x), main, prep), eval_sym(load(y), main, prep)),
     }
   }
 
@@ -550,7 +562,7 @@ def verifier := ⟦
   -- `lookup.rs::fingerprint`).
   fn fingerprint_ext(r: Ext, args: List‹SymExpr›, main: List‹Ext›, prep: List‹Ext›) -> Ext {
     match load(args) {
-      ListNode.Nil => [gl_zero(), gl_zero()],
+      ListNode.Nil => [0, 0],
       ListNode.Cons(a, rest) =>
         eg_add(eval_sym(a, main, prep), eg_mul(r, fingerprint_ext(r, rest, main, prep))),
     }
@@ -573,7 +585,7 @@ def verifier := ⟦
       0 => acc,
       _ =>
         let x = list_lookup(main, idx);
-        let bc = eg_mul(x, eg_sub(x, [gl_one(), gl_zero()]));
+        let bc = eg_mul(x, eg_sub(x, [1, 0]));
         fold_sel_bools(ood_fold(acc, alpha, bc), alpha, main, idx + 1, count - 1),
     }
   }
@@ -595,7 +607,7 @@ def verifier := ⟦
         let mult = eval_sym(mult_e, main, prep);
         let fp = fingerprint_ext(fch, args, main, prep);
         let message = eg_add(lch, fp);
-        let c = eg_sub(eg_mul(message, minv), [gl_one(), gl_zero()]);
+        let c = eg_sub(eg_mul(message, minv), [1, 0]);
         let acc = ood_fold(acc, alpha, c);
         let acc_expr = eg_add(acc_expr, eg_mul(mult, minv));
         fold_lookups(acc, alpha, rest, k + 1, main, prep, s2row, lch, fch, acc_expr),
@@ -616,7 +628,7 @@ def verifier := ⟦
     match air {
       SysAir.Function(c) =>
         let SysConstraints.Mk(zeros, ss, se, _w) = c;
-        let acc = fold_zeros([gl_zero(), gl_zero()], alpha, zeros, main);
+        let acc = fold_zeros([0, 0], alpha, zeros, main);
         let acc = fold_sel_bools(acc, alpha, main, ss, se - ss);
         ood_comp_tail(acc, lookups, main, prep, s2row, s2next, isf, isl, ist, lch, fch, accp, naccp, alpha),
       SysAir.Memory(m) =>
@@ -627,18 +639,18 @@ def verifier := ⟦
         let is_real_next = list_lookup(main_next, 1);
         let ptr_next = list_lookup(main_next, 2);
         -- assert_bool(is_real)
-        let acc = ood_fold([gl_zero(), gl_zero()], alpha, eg_mul(is_real, eg_sub(is_real, [gl_one(), gl_zero()])));
+        let acc = ood_fold([0, 0], alpha, eg_mul(is_real, eg_sub(is_real, [1, 0])));
         -- is_real_transition = is_real_next · is_transition
         let irt = eg_mul(is_real_next, ist);
         -- when(irt).assert_one(is_real) = irt·(is_real - 1)
-        let acc = ood_fold(acc, alpha, eg_mul(irt, eg_sub(is_real, [gl_one(), gl_zero()])));
+        let acc = ood_fold(acc, alpha, eg_mul(irt, eg_sub(is_real, [1, 0])));
         -- when(irt).assert_eq(ptr+1, ptr_next) = irt·(ptr + 1 - ptr_next)
-        let acc = ood_fold(acc, alpha, eg_mul(irt, eg_sub(eg_add(ptr, [gl_one(), gl_zero()]), ptr_next)));
+        let acc = ood_fold(acc, alpha, eg_mul(irt, eg_sub(eg_add(ptr, [1, 0]), ptr_next)));
         ood_comp_tail(acc, lookups, main, prep, s2row, s2next, isf, isl, ist, lch, fch, accp, naccp, alpha),
       SysAir.Bytes1 =>
-        ood_comp_tail([gl_zero(), gl_zero()], lookups, main, prep, s2row, s2next, isf, isl, ist, lch, fch, accp, naccp, alpha),
+        ood_comp_tail([0, 0], lookups, main, prep, s2row, s2next, isf, isl, ist, lch, fch, accp, naccp, alpha),
       SysAir.Bytes2 =>
-        ood_comp_tail([gl_zero(), gl_zero()], lookups, main, prep, s2row, s2next, isf, isl, ist, lch, fch, accp, naccp, alpha),
+        ood_comp_tail([0, 0], lookups, main, prep, s2row, s2next, isf, isl, ist, lch, fch, accp, naccp, alpha),
     }
   }
 
@@ -671,33 +683,32 @@ def verifier := ⟦
   -- with `Z_{Dₖ}(x) = (x · shift_k⁻¹)^(2^L) - 1`.
   -- ==========================================================================
 
-  -- base-field power `base^e` (e small: the chunk index, < qd). `base` is a
-  -- non-native Goldilocks element; `e` is a native loop counter.
-  fn g_pow(base: [U8; 8], e: G) -> [U8; 8] {
+  -- base-field power `base^e` (e small: the chunk index, < qd).
+  fn g_pow(base: Goldilocks, e: G) -> Goldilocks {
     match e {
-      0 => gl_one(),
+      0 => 1,
       _ => gl_mul(base, g_pow(base, e - 1)),
     }
   }
 
   -- `Z_{Dⱼ}(x) = (x · shift_j⁻¹)^(2^L) - 1`, evaluated at extension point `x`.
-  fn vanish_chunk(x: Ext, l: G, shiftinv: [U8; 8]) -> Ext {
-    eg_sub(ext_exp_pow2(eg_mul(x, [shiftinv, gl_zero()]), l), [gl_one(), gl_zero()])
+  fn vanish_chunk(x: Ext, l: G, shiftinv: Goldilocks) -> Ext {
+    eg_sub(ext_exp_pow2(eg_mul(x, [shiftinv, 0]), l), [1, 0])
   }
 
   -- `zpsₜ = Πⱼ≠ₜ Z_{Dⱼ}(ζ) / Z_{Dⱼ}(shift_t)`. Iterates j over `[jidx, jidx+rem)`.
-  fn zps_prod(acc: Ext, zeta: Ext, l: G, g_q: [U8; 8], shift_t: [U8; 8], jidx: G, rem: G, t: G) -> Ext {
+  fn zps_prod(acc: Ext, zeta: Ext, l: G, g_q: Goldilocks, shift_t: Goldilocks, jidx: G, rem: G, t: G) -> Ext {
     match rem {
       0 => acc,
       _ =>
-        let shiftinv = gl_inverse(gl_mul(gl_seven(), g_pow(g_q, jidx)));
+        let shiftinv = gl_inverse(gl_mul(7, g_pow(g_q, jidx)));
         -- skip the j = t factor (the chunk's own domain); branch in tail
         -- position so the inner match is not a non-tail match.
         match eq_zero(jidx - t) {
           1 => zps_prod(acc, zeta, l, g_q, shift_t, jidx + 1, rem - 1, t),
           _ =>
             let factor = eg_mul(vanish_chunk(zeta, l, shiftinv),
-                                 eg_inverse(vanish_chunk([shift_t, gl_zero()], l, shiftinv)));
+                                 eg_inverse(vanish_chunk([shift_t, 0], l, shiftinv)));
             zps_prod(eg_mul(acc, factor), zeta, l, g_q, shift_t, jidx + 1, rem - 1, t),
         },
     }
@@ -705,13 +716,13 @@ def verifier := ⟦
 
   -- `quotient(ζ) = Σₜ zpsₜ · from_ext_basis(chunkₜ)`, iterating the `qd` chunks
   -- (`q_opened[idx][0] = [c0, c1]`).
-  fn quotient_sum(acc: Ext, zeta: Ext, l: G, qd: G, g_q: [U8; 8],
+  fn quotient_sum(acc: Ext, zeta: Ext, l: G, qd: G, g_q: Goldilocks,
       q_opened: OpenedRound, idx: G, rem: G, t: G) -> Ext {
     match rem {
       0 => acc,
       _ =>
-        let shift_t = gl_mul(gl_seven(), g_pow(g_q, t));
-        let zps_t = zps_prod([gl_one(), gl_zero()], zeta, l, g_q, shift_t, 0, qd, t);
+        let shift_t = gl_mul(7, g_pow(g_q, t));
+        let zps_t = zps_prod([1, 0], zeta, l, g_q, shift_t, 0, qd, t);
         let ch = list_lookup(q_opened, idx);
         let row = list_lookup(ch, 0);
         let qv = from_ext_basis(list_lookup(row, 0), list_lookup(row, 1));
@@ -787,7 +798,7 @@ def verifier := ⟦
         let comp = ood_composition(air, lookups, main, main_next, s2row, s2next,
                                    prep, isf, isl, ist, lch, fch, accp, naccp, alpha);
         let g_q = two_adic_gen(l + log_qd);
-        let quot = quotient_sum([gl_zero(), gl_zero()], zeta, l, qd, g_q, q_opened, lastq, qd, 0);
+        let quot = quotient_sum([0, 0], zeta, l, qd, g_q, q_opened, lastq, qd, 0);
         assert_eq!(eg_eq(eg_mul(comp, invv), quot), 1);
         ood_loop(rest, prep_indices, log_degrees, accs, stage1, stage2, prep_opt,
                  q_opened, i + 1, naccp, lastq + qd, lch, fch, alpha, zeta),
@@ -798,9 +809,9 @@ def verifier := ⟦
   -- its raw u64 limb to an extension element). Mirrors `lookup::fingerprint`.
   fn fingerprint_vals(fch: Ext, vals: List‹U64›) -> Ext {
     match load(vals) {
-      ListNode.Nil => [gl_zero(), gl_zero()],
+      ListNode.Nil => [0, 0],
       ListNode.Cons(v, rest) =>
-        eg_add([gl_reduce(v), gl_zero()], eg_mul(fch, fingerprint_vals(fch, rest))),
+        eg_add([gl_val(v), 0], eg_mul(fch, fingerprint_vals(fch, rest))),
     }
   }
 
@@ -834,18 +845,66 @@ def verifier := ⟦
     assert_eq!(eq_zero(vk_num_queries - num_queries), 1);
     assert_eq!(eq_zero(vk_commit_pow_bits - commit_pow_bits), 1);
     match proof {
-      Proof.Mk(commitments, accs, log_degrees, opening,
+      Proof.Mk(active, commitments, accs, log_degrees, opening,
                q_opened, prep_opt, stage1, stage2) =>
+        -- Sparse activation: the bitmap covers the canonical circuit set;
+        -- each bit must be boolean; every per-circuit proof sequence is
+        -- indexed by ACTIVE position, so the verifying key's circuit and
+        -- preprocessed-index lists are filtered to the active subset once
+        -- and everything downstream runs on the filtered lists. Soundness
+        -- of deactivation rests on the lookup accumulator: an inactive
+        -- circuit contributes no sends or receives, and dishonestly
+        -- deactivating a needed circuit leaves the final accumulator
+        -- nonzero (checked in `verify`).
+        assert_eq!(assert_bits(active), 1);
+        assert_eq!(eq_zero(list_length(active) - list_length(circuits)), 1);
+        let acirc = select_active_circuits(circuits, active);
+        let aprep = select_active_prep(prep_indices, active);
+        assert_eq!(eq_zero(list_length(acirc) - list_length(accs)), 1);
         let Commitments.Mk(s1c, s2c, qc) = commitments;
         let prep_cap = opt_commit_cap(commit);
-        let (lch, fch, alpha, zeta, post_zeta_input) = fiat_shamir(tlimbs, prep_cap, s1c, s2c, qc, log_degrees, claims, accs);
-        let acc0 = claims_acc([gl_zero(), gl_zero()], claims, lch, fch);
-        -- Step 5: OOD composition/quotient identity for every circuit.
-        let _ood = ood_loop(circuits, prep_indices, log_degrees, accs, stage1, stage2,
+        let (lch, fch, alpha, zeta, post_zeta_input) = fiat_shamir(tlimbs, active, prep_cap, s1c, s2c, qc, log_degrees, claims, accs);
+        let acc0 = claims_acc([0, 0], claims, lch, fch);
+        -- Step 5: OOD composition/quotient identity for every active circuit.
+        let _ood = ood_loop(acirc, aprep, log_degrees, accs, stage1, stage2,
                  prep_opt, q_opened, 0, acc0, 0, lch, fch, alpha, zeta);
         pcs_fri_verify(post_zeta_input, stage1, stage2, q_opened, prep_opt, opening,
-          s1c, s2c, qc, prep_cap, circuits, prep_indices, log_degrees, zeta,
-          list_length(circuits), log_blowup, num_queries, commit_pow_bits),
+          s1c, s2c, qc, prep_cap, acirc, aprep, log_degrees, zeta,
+          list_length(acirc), log_blowup, num_queries, commit_pow_bits),
+    }
+  }
+
+  -- 1 iff every element of `l` is boolean (0 or 1).
+  fn assert_bits(l: List‹G›) -> G {
+    match load(l) {
+      ListNode.Nil => 1,
+      ListNode.Cons(b, rest) =>
+        assert_eq!(b * (b - 1), 0);
+        assert_bits(rest),
+    }
+  }
+  -- The verifying key's circuits at active positions, in order.
+  fn select_active_circuits(circuits: List‹SysCircuit›, active: List‹G›) -> List‹SysCircuit› {
+    match load(circuits) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(c, crest) =>
+        let &ListNode.Cons(b, arest) = active;
+        match b {
+          0 => select_active_circuits(crest, arest),
+          _ => store(ListNode.Cons(c, select_active_circuits(crest, arest))),
+        },
+    }
+  }
+  -- The preprocessed-index entries at active positions, in order.
+  fn select_active_prep(prep_indices: List‹OptIdx›, active: List‹G›) -> List‹OptIdx› {
+    match load(prep_indices) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(p, prest) =>
+        let &ListNode.Cons(b, arest) = active;
+        match b {
+          0 => select_active_prep(prest, arest),
+          _ => store(ListNode.Cons(p, select_active_prep(prest, arest))),
+        },
     }
   }
 
@@ -867,7 +926,16 @@ def verifier := ⟦
   }
   fn read_one_claim(stream: ByteStream) -> (List‹U64›, ByteStream) {
     let (m, s) = read_count(stream);
-    read_u64_vec_n(s, m)
+    read_claim_vals_n(s, m)
+  }
+  fn read_claim_vals_n(stream: ByteStream, n: G) -> (List‹U64›, ByteStream) {
+    match n {
+      0 => (store(ListNode.Nil), stream),
+      _ =>
+        let (x, s) = read_u64(stream);
+        let (rest, s2) = read_claim_vals_n(s, n - 1);
+        (store(ListNode.Cons(x, rest)), s2),
+    }
   }
 ⟧
 
diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean
index 498d19f98..b6366effe 100644
--- a/Tests/Ix/IxVM.lean
+++ b/Tests/Ix/IxVM.lean
@@ -252,19 +252,16 @@ public def runParityCase (compiled : Aiur.CompiledToplevel)
           (bQC.zip cQC).all fun (b, c) =>
             b.uniqueRows == c.uniqueRows && b.totalHits == c.totalHits)
 
-/-- Parity fixtures: `kernel_unit_tests` covers the level primitives
-    end-to-end with zero IO, and every pinned `kernelCheckEntries`
-    constant runs a realistic workload (blake3, ingress, whnf, def-eq,
-    recursor gen) against the same IOBuffer under both engines. -/
+/-- 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. -/
 public def parityCases (env : Lean.Environment) : IO (List AiurTestCase) := do
-  let emptyIO : Aiur.IOBuffer := { data := ∅, map := ∅ }
-  let kunit : AiurTestCase :=
-    { functionName := `kernel_unit_tests, label := "kernel_unit_tests"
-      input := #[], inputIOBuffer := emptyIO
-      expectedIOBuffer := emptyIO, interpret := false, executionOnly := true }
-  let checks ← kernelCheckEntries.mapM fun (name, _) =>
+  kernelCheckEntries.mapM fun (name, _) =>
     kernelCheck (nameOfString name) env
-  pure (kunit :: checks)
 
 /-! ## Claim variant smoke tests
 
diff --git a/Tests/Main.lean b/Tests/Main.lean
index e6e85cd03..911e94d50 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -102,20 +102,21 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
     let kernelChecks ← kernelChecks env
     let claimSmokes ← claimSmokeTests env
     let parityCases ← parityCases env
-    let aiurTests := [kernelUnitTests, serdeNatAddCommTest]
-                     ++ kernelChecks ++ claimSmokes
-    -- The arena suite shares the compiled toplevel with the AiurTestCase
-    -- runs above; build it once here and weave the resulting TestSeq in
-    -- alongside `mkAiurTests`'s output.
-    match AiurTestEnv.build IxVM.ixVM with
-    | .error e => IO.eprintln s!"IxVM env build failed: {e}"; return 1
-    | .ok aiurEnv =>
+    -- 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.
+    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 aiurSeq := aiurTests.foldl (init := .done) fun s tc =>
+      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
       let paritySeq := parityCases.foldl (init := .done) fun s tc =>
         s ++ runParityCase aiurEnv.compiled tc
-      LSpec.lspecIO (.ofList [("ixvm", [aiurSeq, arenaSeq, paritySeq])]) []),
+      LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, paritySeq])]) []),
   ("rbtree-map", do
     IO.println "rbtree-map"
     match AiurTestEnv.build (pure IxVM.rbTreeMap) with
diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean
index a22a214af..853968d9c 100644
--- a/Tests/MultiStark.lean
+++ b/Tests/MultiStark.lean
@@ -62,6 +62,9 @@ and a one-line description of what each validates against the Rust reference. -/
 def selfTests : List (Lean.Name × String) := [
   (`pcs_hash_test, "Blake3 MMCS leaf/compress match reference"),
   (`pcs_merkle_test, "Merkle verify_batch matches reference (root + tamper)"),
+  (`lane_hash_test, "lane-granular leaf blake3 matches byte blake3 (blocks/chunks/fold)"),
+  (`io_hash_test, "IO-slice blake3 matches byte blake3 (blocks/chunks/fold)"),
+  (`rows_hash_test, "rows-walking leaf hash matches concat+canon reference"),
   (`sample_bits_test, "challenger sample_bits matches reference"),
   (`pcs_challenger4_test, "PCS challenger continuation (α_pcs/α_fri/β/index) matches reference"),
   (`fri_fold_test, "FRI arity-2 fold_row matches reference"),
@@ -175,7 +178,8 @@ def endToEndSuite : IO UInt32 := do
   -- ── negative-test inputs ────────────────────────────────────────────────────
   -- Tampered proof advice: flip byte 0 (the first stage_1-commitment limb) so the
   -- replayed Fiat-Shamir transcript diverges from the one the proof was made under.
-  let badProofGs := proofGs.set! 0 (Aiur.G.ofNat ((proofBytes.data[0]!.toNat + 1) % 256))
+  let badProofBytes :=
+    proofBytes.set! 0 (UInt8.ofNat ((proofBytes.data[0]!.toNat + 1) % 256))
   -- Tampered claim (with a matching keccak digest): 120 → 121. Feeds a different
   -- value into Fiat-Shamir (→ different ζ) and the lookup accumulator, so the
   -- composition/quotient identity no longer holds even though the binding passes.
@@ -187,14 +191,28 @@ def endToEndSuite : IO UInt32 := do
   -- ── run the (expensive) checks, then assert ─────────────────────────────────
   IO.println "recursive-verifier (proving + recursive verification, ~1.5 min)…"
   let innerVerify := facSystem.verify claim (.ofBytes proofBytes)
-  let honest := vCompiled.bytecode.execute vIdx pubInput (mkIO proofGs claimGs)
-  let tamperedProof := vCompiled.bytecode.execute vIdx pubInput (mkIO badProofGs claimGs)
+  -- Native path: Rust-built advice buffer + codegen'd verifier
+  -- (`crates/ixvm-codegen/src/aiur_multi_stark.rs`).
+  let honest :=
+    vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes vkBytes claimBytes
+  -- Interpreter over the Lean-built buffer: the parity reference for the
+  -- codegen'd verifier — same output, same per-circuit query counts.
+  let honestInterp := vCompiled.bytecode.execute vIdx pubInput (mkIO proofGs claimGs)
+  let parity : Bool := match honest, honestInterp with
+    | .ok (out, qc), .ok (outI, _, qcI) =>
+      out == outI && qc.size == qcI.size &&
+        (qc.zip qcI).all fun (a, b) =>
+          a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits
+    | _, _ => false
+  let tamperedProof :=
+    vCompiled.bytecode.executeMultiStark vIdx pubInput badProofBytes vkBytes claimBytes
   let tamperedClaim :=
-    vCompiled.bytecode.execute vIdx badClaimInput (mkIO proofGs (badClaimBytes.data.map .ofUInt8))
+    vCompiled.bytecode.executeMultiStark vIdx badClaimInput proofBytes vkBytes badClaimBytes
   lspecIO (.ofList [("recursive-verifier", [
     test "factorial(5) claim = #[functionChannel, facIdx, 5, 120]" (claim == expectedClaim),
     expectOk "inner factorial proof verifies" innerVerify,
     expectOk "verifier accepts honest proof (vk digest bound + OOD + FRI)" honest,
+    test "codegen'd verifier matches interpreter (output + query counts)" parity,
     expectErr "tampered proof advice rejected (verification checks)" tamperedProof,
     expectErr "tampered claim rejected (OOD/accumulator mismatch)" tamperedClaim,
   ])]) []
diff --git a/crates/aiur/Cargo.toml b/crates/aiur/Cargo.toml
index 3da792ae4..9061574a0 100644
--- a/crates/aiur/Cargo.toml
+++ b/crates/aiur/Cargo.toml
@@ -7,6 +7,7 @@ license.workspace = true
 [dependencies]
 hashbrown = { workspace = true }
 indexmap = { workspace = true }
+libc = { workspace = true }
 multi-stark = { workspace = true }
 num-bigint = { workspace = true }
 rayon = { workspace = true }
diff --git a/crates/aiur/src/bytecode.rs b/crates/aiur/src/bytecode.rs
index 6f1b6be83..7da57a2a5 100644
--- a/crates/aiur/src/bytecode.rs
+++ b/crates/aiur/src/bytecode.rs
@@ -73,6 +73,15 @@ pub enum Op {
   /// and no constraints generated. The caller is responsible for verifying
   /// the relation in constrained code.
   UnconstrainedBigUintDivMod(ValIdx, ValIdx),
+  /// Unconstrained hint: the 8 little-endian bytes of a field element's
+  /// canonical `u64` value. 8 fresh auxiliary values, no constraints, no
+  /// lookup; the caller must range-check the bytes, assert they recompose
+  /// to the input, and assert canonicality (`< p`) in constrained code.
+  UnconstrainedGToBytes(ValIdx),
+  /// Unconstrained hint: the field inverse of a value (`0 ↦ 0`). One fresh
+  /// auxiliary value, no constraints; the caller must pin it via
+  /// multiply-and-assert.
+  UnconstrainedGInverse(ValIdx),
 }
 
 pub enum Ctrl {
diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs
index 93fda0e0f..1cbf07663 100644
--- a/crates/aiur/src/constraints.rs
+++ b/crates/aiur/src/constraints.rs
@@ -685,6 +685,21 @@ impl Op {
           state.map.push((col, 1));
         }
       },
+      Op::UnconstrainedGToBytes(_) => {
+        // Unconstrained hint bytes: 8 fresh auxiliary columns, no relation,
+        // no lookup. The caller pins them (range checks + recomposition +
+        // canonicality asserts) in constrained code.
+        for _ in 0..8 {
+          let col = state.next_auxiliary();
+          state.map.push((col, 1));
+        }
+      },
+      Op::UnconstrainedGInverse(_) => {
+        // Unconstrained hint inverse: one fresh auxiliary column, no
+        // relation. The caller pins it via multiply-and-assert.
+        let col = state.next_auxiliary();
+        state.map.push((col, 1));
+      },
     }
   }
 }
diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs
index 561f2ee33..389dfb5b4 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -1,4 +1,4 @@
-use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
+use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64};
 use rustc_hash::FxHashMap;
 use std::collections::hash_map::Entry;
 
@@ -584,6 +584,18 @@ impl Function {
           map.push(q_ptr);
           map.push(r_ptr);
         },
+        ExecEntry::Op(Op::UnconstrainedGToBytes(a_idx)) => {
+          // Unconstrained hint: the 8 LE bytes of the canonical u64 value.
+          // No record side effects — the caller pins the bytes with range
+          // checks + a recomposition assert + a canonicality assert.
+          let bytes = map[*a_idx].as_canonical_u64().to_le_bytes();
+          map.extend(bytes.iter().map(|b| G::from_u8(*b)));
+        },
+        ExecEntry::Op(Op::UnconstrainedGInverse(a_idx)) => {
+          // Unconstrained hint: the field inverse (`0 ↦ 0`). No record side
+          // effects — the caller pins it via multiply-and-assert.
+          map.push(g_inverse_value(map[*a_idx]));
+        },
         ExecEntry::Op(Op::Debug(label, idxs)) => match idxs {
           None => println!("{label}"),
           Some(idxs) => {
@@ -817,6 +829,14 @@ pub fn bytes2_sub_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) {
 pub use crate::gadgets::bytes1::Bytes1 as CodegenBytes1;
 pub use crate::gadgets::bytes2::Bytes2 as CodegenBytes2;
 
+/// The value of the `UnconstrainedGInverse` hint: the field inverse, with
+/// `0 ↦ 0`. Shared by the interpreter, the codegen'd kernels, and trace
+/// population so all three produce identical witness values.
+#[inline]
+pub fn g_inverse_value(x: G) -> G {
+  x.try_inverse().unwrap_or(G::ZERO)
+}
+
 /// Helper extracted for the codegen'd kernel: compute the unconstrained
 /// BigUint div-mod and return `(q_ptr, r_ptr)`. Same side effects on
 /// `record.memory_queries` as the inlined `Op::UnconstrainedBigUintDivMod`
diff --git a/crates/aiur/src/memory.rs b/crates/aiur/src/memory.rs
index 738507dcb..0de583129 100644
--- a/crates/aiur/src/memory.rs
+++ b/crates/aiur/src/memory.rs
@@ -58,7 +58,13 @@ impl Memory {
     let queries = record.memory_queries.get(&size).expect("Invalid size");
     let width = Self::width(size);
     let height_no_padding = queries.len();
-    let height = height_no_padding.next_power_of_two();
+    // An unqueried memory table yields an EMPTY trace: the prover
+    // deactivates it, so it is neither committed nor opened.
+    let height = if height_no_padding == 0 {
+      0
+    } else {
+      height_no_padding.next_power_of_two()
+    };
 
     let mut rows = vec![G::ZERO; height * width];
     let rows_no_padding = &mut rows[0..height_no_padding * width];
diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs
index a6b0f37d1..56f97306e 100644
--- a/crates/aiur/src/querymap.rs
+++ b/crates/aiur/src/querymap.rs
@@ -25,121 +25,317 @@ fn hash_g_slice(key: &[G]) -> u64 {
   h.finish()
 }
 
+/// Entries per storage segment (2^20). Segments are fixed-size, so growth
+/// never reallocates or copies: appending past a segment boundary just
+/// allocates the next segment. This removes the O(len) memmove of a growing
+/// `Vec` AND its transient 2x memory spike — on kernel-heavy executions the
+/// arenas reach tens of GB, where a doubling copy is both seconds of pure
+/// memmove and the difference between fitting in RAM and OOM. Capacity is
+/// only reserved virtual address space; physical pages are committed on
+/// first touch, so idle circuits stay tiny.
+const SEG_BITS: usize = 20;
+const SEG_ENTRIES: usize = 1 << SEG_BITS;
+const SEG_MASK: usize = SEG_ENTRIES - 1;
+
+/// A fixed-capacity append-only buffer mmap'd straight from the kernel,
+/// with `MADV_HUGEPAGE` applied BEFORE any page is touched. At billions of
+/// entries the query maps are walked by random probes; with 4K pages nearly
+/// every probe pays a 4-level page walk on top of the DRAM miss, and 2M
+/// pages cut TLB reach pressure by 512x. Going through the global allocator
+/// doesn't work here: mimalloc (the process allocator) commits its segments
+/// itself, so pages are already faulted at 4K before any post-hoc madvise.
+/// Capacity is virtual reservation only — physical pages are committed on
+/// first touch, so idle circuits stay tiny. Off Linux this degrades to a
+/// plain `Vec`.
+struct HugeVec<T: Copy> {
+  #[cfg(target_os = "linux")]
+  ptr: *mut T,
+  #[cfg(target_os = "linux")]
+  cap: usize,
+  #[cfg(target_os = "linux")]
+  len: usize,
+  #[cfg(not(target_os = "linux"))]
+  inner: Vec<T>,
+}
+
+#[cfg(target_os = "linux")]
+unsafe impl<T: Copy + Send> Send for HugeVec<T> {}
+#[cfg(target_os = "linux")]
+unsafe impl<T: Copy + Sync> Sync for HugeVec<T> {}
+
+impl<T: Copy> HugeVec<T> {
+  #[cfg(target_os = "linux")]
+  fn with_capacity(cap: usize) -> Self {
+    assert!(cap > 0, "HugeVec capacity must be positive");
+    let bytes = cap * size_of::<T>();
+    let ptr = unsafe {
+      let p = libc::mmap(
+        std::ptr::null_mut(),
+        bytes,
+        libc::PROT_READ | libc::PROT_WRITE,
+        libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
+        -1,
+        0,
+      );
+      assert!(p != libc::MAP_FAILED, "HugeVec mmap failed");
+      // Advisory only: failure (old kernel, THP disabled) is harmless.
+      libc::madvise(p, bytes, libc::MADV_HUGEPAGE);
+      p.cast::<T>()
+    };
+    Self { ptr, cap, len: 0 }
+  }
+
+  #[cfg(not(target_os = "linux"))]
+  fn with_capacity(cap: usize) -> Self {
+    Self { inner: Vec::with_capacity(cap) }
+  }
+
+  #[cfg(target_os = "linux")]
+  #[inline]
+  fn extend_from_slice(&mut self, vals: &[T]) {
+    debug_assert!(self.len + vals.len() <= self.cap);
+    unsafe {
+      std::ptr::copy_nonoverlapping(
+        vals.as_ptr(),
+        self.ptr.add(self.len),
+        vals.len(),
+      );
+    }
+    self.len += vals.len();
+  }
+
+  #[cfg(not(target_os = "linux"))]
+  #[inline]
+  fn extend_from_slice(&mut self, vals: &[T]) {
+    self.inner.extend_from_slice(vals);
+  }
+
+  #[cfg(target_os = "linux")]
+  #[inline]
+  fn slice(&self, start: usize, len: usize) -> &[T] {
+    debug_assert!(start + len <= self.len);
+    unsafe { std::slice::from_raw_parts(self.ptr.add(start), len) }
+  }
+
+  #[cfg(not(target_os = "linux"))]
+  #[inline]
+  fn slice(&self, start: usize, len: usize) -> &[T] {
+    &self.inner[start..start + len]
+  }
+
+  #[cfg(target_os = "linux")]
+  #[inline]
+  fn slice_mut(&mut self, start: usize, len: usize) -> &mut [T] {
+    debug_assert!(start + len <= self.len);
+    unsafe { std::slice::from_raw_parts_mut(self.ptr.add(start), len) }
+  }
+
+  #[cfg(not(target_os = "linux"))]
+  #[inline]
+  fn slice_mut(&mut self, start: usize, len: usize) -> &mut [T] {
+    &mut self.inner[start..start + len]
+  }
+}
+
+#[cfg(target_os = "linux")]
+impl<T: Copy> Drop for HugeVec<T> {
+  fn drop(&mut self) {
+    unsafe {
+      libc::munmap(self.ptr.cast(), self.cap * size_of::<T>());
+    }
+  }
+}
+
+/// Append-only segmented arena of fixed-stride `G` entries. Entry `i` lives
+/// at segment `i >> SEG_BITS`, offset `(i & SEG_MASK) * stride` — no entry
+/// ever straddles a segment.
+struct SegStore {
+  stride: usize,
+  segs: Vec<HugeVec<G>>,
+  entries: usize,
+}
+
+impl SegStore {
+  fn new(stride: usize) -> Self {
+    Self { stride, segs: Vec::new(), entries: 0 }
+  }
+
+  #[inline]
+  fn at(&self, i: usize) -> &[G] {
+    if self.stride == 0 {
+      return &[];
+    }
+    let base = (i & SEG_MASK) * self.stride;
+    self.segs[i >> SEG_BITS].slice(base, self.stride)
+  }
+
+  #[inline]
+  fn at_mut(&mut self, i: usize) -> &mut [G] {
+    if self.stride == 0 {
+      return &mut [];
+    }
+    let base = (i & SEG_MASK) * self.stride;
+    self.segs[i >> SEG_BITS].slice_mut(base, self.stride)
+  }
+
+  #[inline]
+  fn push(&mut self, vals: &[G]) {
+    debug_assert_eq!(vals.len(), self.stride);
+    if self.stride != 0 {
+      let seg = self.entries >> SEG_BITS;
+      if seg == self.segs.len() {
+        self.segs.push(HugeVec::with_capacity(SEG_ENTRIES * self.stride));
+      }
+      self.segs[seg].extend_from_slice(vals);
+    }
+    self.entries += 1;
+  }
+
+  fn retained_elems(&self) -> usize {
+    self.entries * self.stride
+  }
+}
+
+/// Segmented store of per-entry key hashes. Kept so hash-table growth can
+/// re-insert from stored hashes instead of re-hashing every key from the
+/// keys arena — table doubling on a multi-GB map used to be a full
+/// sequential re-hash pass over the arena, log-many times.
+struct SegHashes {
+  segs: Vec<HugeVec<u64>>,
+  entries: usize,
+}
+
+impl SegHashes {
+  fn new() -> Self {
+    Self { segs: Vec::new(), entries: 0 }
+  }
+
+  #[inline]
+  fn at(&self, i: usize) -> u64 {
+    self.segs[i >> SEG_BITS].slice(i & SEG_MASK, 1)[0]
+  }
+
+  #[inline]
+  fn push(&mut self, h: u64) {
+    let seg = self.entries >> SEG_BITS;
+    if seg == self.segs.len() {
+      self.segs.push(HugeVec::with_capacity(SEG_ENTRIES));
+    }
+    self.segs[seg].extend_from_slice(&[h]);
+    self.entries += 1;
+  }
+}
+
 /// Append-only query store with a hash index.
 ///
 /// Functionally the insertion-ordered map `args -> (output, multiplicity)`
 /// it replaces (`FxIndexMap<Vec<G>, QueryResult>`) — but every circuit has
 /// a FIXED key arity and output width, so keys and outputs live in flat
-/// `Vec<G>` arenas addressed by entry index, and the hash table holds only
-/// `u32` indices. This cuts per-entry overhead from ~130 B (two heap
+/// segmented `G` arenas addressed by entry index, and the hash table holds
+/// only `u32` indices. This cuts per-entry overhead from ~130 B (two heap
 /// `Vec`s + IndexMap bucket + allocator metadata) to the raw field
-/// elements plus ~13 B of index. The record IS the proof witness, so
-/// entries cannot be dropped — only stored compactly; on kernel-heavy
-/// executions it is the dominant RAM consumer (billions of entries).
+/// elements plus ~21 B of index + stored hash. The record IS the proof
+/// witness, so entries cannot be dropped — only stored compactly; on
+/// kernel-heavy executions it is the dominant RAM consumer (billions of
+/// entries). Segmented storage keeps growth copy-free (no doubling
+/// memmove, no transient 2x RSS), stored hashes make table growth a cheap
+/// sequential pass, and segments are hugepage-advised (see `advise_huge`).
 ///
 /// Entry index == insertion order; memory circuits use it as the pointer
 /// value, mirroring the old `IndexMap::get_index_of` semantics.
 pub struct QueryMap {
-  key_stride: usize,
   /// Output width; inferred on first insert (not statically available in
   /// `FunctionLayout`).
-  out_stride: usize,
-  keys: Vec<G>,
-  outs: Vec<G>,
-  mults: Vec<G>,
+  out_stride_set: bool,
+  keys: SegStore,
+  outs: SegStore,
+  mults: SegStore,
+  hashes: SegHashes,
   table: hashbrown::HashTable<u32>,
 }
 
 impl QueryMap {
   pub fn new(key_stride: usize) -> Self {
     Self {
-      key_stride,
-      out_stride: 0,
-      keys: Vec::new(),
-      outs: Vec::new(),
-      mults: Vec::new(),
+      out_stride_set: false,
+      keys: SegStore::new(key_stride),
+      outs: SegStore::new(0),
+      mults: SegStore::new(1),
+      hashes: SegHashes::new(),
       table: hashbrown::HashTable::new(),
     }
   }
 
   #[inline]
   pub fn len(&self) -> usize {
-    self.mults.len()
+    self.mults.entries
   }
 
   #[inline]
   pub fn is_empty(&self) -> bool {
-    self.mults.is_empty()
+    self.mults.entries == 0
   }
 
   /// Total retained field elements (keys + outputs); used by the
   /// `IX_AIUR_QUERY_STATS` RAM-attribution dump.
   pub fn retained_elems(&self) -> usize {
-    self.keys.len() + self.outs.len()
-  }
-
-  #[inline]
-  fn key_at(&self, i: usize) -> &[G] {
-    &self.keys[i * self.key_stride..(i + 1) * self.key_stride]
-  }
-
-  #[inline]
-  fn out_at(&self, i: usize) -> &[G] {
-    &self.outs[i * self.out_stride..(i + 1) * self.out_stride]
+    self.keys.retained_elems() + self.outs.retained_elems()
   }
 
   pub fn get_index_of(&self, key: &[G]) -> Option<usize> {
-    debug_assert_eq!(key.len(), self.key_stride);
+    debug_assert_eq!(key.len(), self.keys.stride);
     let hash = hash_g_slice(key);
     self
       .table
-      .find(hash, |&i| self.key_at(i as usize) == key)
+      .find(hash, |&i| self.keys.at(i as usize) == key)
       .map(|&i| i as usize)
   }
 
   pub fn get(&self, key: &[G]) -> Option<QueryRef<'_>> {
     let i = self.get_index_of(key)?;
-    Some(QueryRef { output: self.out_at(i), multiplicity: self.mults[i] })
+    Some(QueryRef {
+      output: self.outs.at(i),
+      multiplicity: self.mults.at(i)[0],
+    })
   }
 
   pub fn get_mut(&mut self, key: &[G]) -> Option<QueryRefMut<'_>> {
     let i = self.get_index_of(key)?;
-    let output = &self.outs[i * self.out_stride..(i + 1) * self.out_stride];
-    Some(QueryRefMut { output, multiplicity: &mut self.mults[i] })
+    Some(QueryRefMut {
+      output: self.outs.at(i),
+      multiplicity: &mut self.mults.at_mut(i)[0],
+    })
   }
 
   /// Append a new entry. The key must not already be present: call sites
   /// only insert on a confirmed miss, and a same-key re-entrant call
   /// would loop forever before reaching its own insert.
   pub fn insert(&mut self, key: &[G], output: &[G], multiplicity: G) {
-    debug_assert_eq!(key.len(), self.key_stride);
+    debug_assert_eq!(key.len(), self.keys.stride);
     debug_assert!(self.get_index_of(key).is_none());
-    if self.mults.is_empty() {
-      self.out_stride = output.len();
+    if !self.out_stride_set {
+      self.outs.stride = output.len();
+      self.out_stride_set = true;
     } else {
-      debug_assert_eq!(output.len(), self.out_stride);
+      debug_assert_eq!(output.len(), self.outs.stride);
     }
     let hash = hash_g_slice(key);
-    let i = u32::try_from(self.mults.len()).expect("query map overflow");
-    self.keys.extend_from_slice(key);
-    self.outs.extend_from_slice(output);
-    self.mults.push(multiplicity);
-    let keys = &self.keys;
-    let stride = self.key_stride;
-    self.table.insert_unique(hash, i, |&j| {
-      let j = j as usize;
-      hash_g_slice(&keys[j * stride..(j + 1) * stride])
-    });
+    let i = u32::try_from(self.mults.entries).expect("query map overflow");
+    self.keys.push(key);
+    self.outs.push(output);
+    self.mults.push(&[multiplicity]);
+    self.hashes.push(hash);
+    let hashes = &self.hashes;
+    self.table.insert_unique(hash, i, |&j| hashes.at(j as usize));
   }
 
   /// Entry at insertion index `i`: the key slice plus a mutable handle on
   /// the multiplicity (memory `Load` bumps the pointed-to row's count).
   pub fn get_index_mut(&mut self, i: usize) -> Option<(&[G], &mut G)> {
-    if i >= self.mults.len() {
+    if i >= self.mults.entries {
       return None;
     }
-    let key = &self.keys[i * self.key_stride..(i + 1) * self.key_stride];
-    Some((key, &mut self.mults[i]))
+    Some((self.keys.at(i), &mut self.mults.at_mut(i)[0]))
   }
 
   pub fn get_index(&self, i: usize) -> Option<(&[G], QueryRef<'_>)> {
@@ -147,16 +343,16 @@ impl QueryMap {
       return None;
     }
     Some((
-      self.key_at(i),
-      QueryRef { output: self.out_at(i), multiplicity: self.mults[i] },
+      self.keys.at(i),
+      QueryRef { output: self.outs.at(i), multiplicity: self.mults.at(i)[0] },
     ))
   }
 
   pub fn iter(&self) -> impl Iterator<Item = (&[G], QueryRef<'_>)> {
     (0..self.len()).map(|i| {
       (
-        self.key_at(i),
-        QueryRef { output: self.out_at(i), multiplicity: self.mults[i] },
+        self.keys.at(i),
+        QueryRef { output: self.outs.at(i), multiplicity: self.mults.at(i)[0] },
       )
     })
   }
diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs
index 5b45d06c3..6fb80d697 100644
--- a/crates/aiur/src/trace.rs
+++ b/crates/aiur/src/trace.rs
@@ -15,6 +15,7 @@ use crate::{
   bytecode::{Block, Ctrl, Function, Op, Toplevel},
   execute::{
     IOBuffer, IOKeyInfo, QueryRecord, find_unconstrained_big_uint_div_mod,
+    g_inverse_value,
   },
   function_channel,
   gadgets::{bytes1::Bytes1, bytes2::Bytes2},
@@ -87,7 +88,13 @@ impl Toplevel {
       .filter(|(_, res)| !res.multiplicity.is_zero())
       .collect::<Vec<_>>();
     let height_no_padding = queries.len();
-    let height = height_no_padding.next_power_of_two();
+    // An unqueried circuit yields an EMPTY trace (not a padded height-1 one):
+    // the prover deactivates it, so it is neither committed nor opened.
+    let height = if height_no_padding == 0 {
+      0
+    } else {
+      height_no_padding.next_power_of_two()
+    };
     let mut rows = vec![G::ZERO; height * width];
     let rows_no_padding = &mut rows[0..height_no_padding * width];
     let empty_lookup = Lookup::empty();
@@ -577,6 +584,21 @@ impl Op {
           slice.push_auxiliary(index, f);
         }
       },
+      Op::UnconstrainedGToBytes(a) => {
+        // Recompute the deterministic hint (canonical LE bytes) and fill
+        // the 8 auxiliary columns the constraints allocate.
+        let bytes = map[*a].0.as_canonical_u64().to_le_bytes();
+        for b in bytes {
+          let f = G::from_u8(b);
+          map.push((f, 1));
+          slice.push_auxiliary(index, f);
+        }
+      },
+      Op::UnconstrainedGInverse(a) => {
+        let f = g_inverse_value(map[*a].0);
+        map.push((f, 1));
+        slice.push_auxiliary(index, f);
+      },
       Op::AssertEq(..)
       | Op::IOSetInfo(..)
       | Op::IOWrite(..)
diff --git a/crates/aiur/src/vk_codec.rs b/crates/aiur/src/vk_codec.rs
index 8effdb271..3604b0685 100644
--- a/crates/aiur/src/vk_codec.rs
+++ b/crates/aiur/src/vk_codec.rs
@@ -9,28 +9,68 @@
 //! and so are *not* serialized.
 //!
 //! This is a **hand-written, serde-free** codec. `multi-stark` does not derive
-//! `serde` on its types, and we do not want to fork it just to add the derives,
-//! so the encoder and decoder are written by hand against the public fields of
-//! `System`, `Circuit`, `LookupAir`, `Lookup`, `SymbolicExpression`,
-//! `SymbolicVariable`, `Entry`, `CommitmentParameters`, `FriParameters` and
-//! the Ix `AiurCircuit`/`Constraints`/`Memory`. The wire format mirrors the
-//! `bincode standard().little_endian().fixed_int` layout the proof uses, so the
-//! Aiur port (`Ix/MultiStark/SystemDeserialize.lean`) can read it the same way.
+//! `serde` on its types, so the encoder and decoder are written by hand against
+//! the public fields of `System`, `Circuit`, `LookupAir`, `Lookup`,
+//! `SymbolicExpression`, `SymbolicVariable`, `Entry`, `CommitmentParameters`,
+//! `FriParameters` and the Ix `AiurCircuit`/`Constraints`/`Memory`. The Aiur
+//! port (`Ix/MultiStark/SystemDeserialize.lean`) reads the same bytes
+//! in-circuit; the two must stay mirror images.
 //!
-//! Wire format:
-//!   enum tag : u32 (4 bytes LE)       Option : 1 byte (0 = None / 1 = Some)
-//!   usize / u64 : 8 bytes LE          Vec : u64 length, then elements
-//!   struct : fields in declaration order      Range<usize> : start, end (u64)
-//!   Goldilocks `G` : canonical u64, 8 bytes LE (the Lean side reduces mod p on
-//!                    read; canonical and raw representations agree there)
-//!   MerkleCap : Vec<[u64; 4]>         PhantomData : 0 bytes
+//! # Split-streams wire format (v2)
 //!
-//! Goldilocks note: bincode/serde would write Goldilocks' *raw* internal `u64`,
-//! but that field is `pub(crate)` inside `p3_goldilocks` and unreachable here.
-//! We instead write `as_canonical_u64()` (the reduced value) and read it back
-//! with `from_u64`. The constants that appear in a verifying key are canonical,
-//! and the Lean reader reduces mod p regardless, so the two representations are
-//! interchangeable.
+//! The recursive verifier hashes every vk byte (digest binding) and reads them
+//! with fixed-size `io_read` chunks, so the format optimizes for (a) few bytes
+//! and (b) fixed-width fields only — no varints. Each field class lives in its
+//! own per-circuit byte segment with a single width:
+//!
+//! ```text
+//! GLOBAL HEADER
+//!   7 x u16 LE   commitment + FRI parameters (log_blowup, cap_height,
+//!                log_final_poly_len, max_log_arity, num_queries,
+//!                commit_proof_of_work_bits, query_proof_of_work_bits)
+//!   u16          circuit count
+//! PER-CIRCUIT RECORDS (circuit count times; each record is a contiguous
+//!                      byte range — a future Merkle leaf)
+//!   5 x u32 LE   segment lengths: TAGS, IDX, C2, C8, META
+//!   TAGS   1 byte per node: low nibble = kind, high nibble = aux
+//!   IDX    2 bytes per Variable: column index (u16 LE)
+//!   C2     2 bytes per small constant (canonical value < 2^16, u16 LE)
+//!   C8     8 bytes per large constant (canonical u64 LE)
+//!   META   4 bytes per count/metadata field (u32 LE)
+//! TRAILER
+//!   u8           preprocessed commit flag (0 = None / 1 = Some)
+//!   [u16 + 32-byte digests]   MerkleCap, if flag = 1
+//!   u16 x circuit count       preprocessed indices (0xFFFF = None)
+//! ```
+//!
+//! TAGS byte: kind 0 = Variable, 1 = IsFirstRow, 2 = IsLastRow,
+//! 3 = IsTransition, 4 = Constant, 5 = Add, 6 = Sub, 7 = Neg, 8 = Mul.
+//! Aux for Variable = entry kind (0 = Preprocessed, 1 = Main, 2 = Stage2,
+//! 3 = Public, 4 = Stage2Public, 5 = Challenge) + 8 * rotation offset (the
+//! rotation is only 0/1: current or next row). Aux for Constant = size class
+//! (0 -> C2, 1 -> C8). A record's first TAGS byte is the `AiurCircuit`
+//! variant tag (0 = Function, 1 = Memory, 2 = Bytes1, 3 = Bytes2), then
+//! expression nodes in preorder.
+//!
+//! Record content order (defines each segment's fill order):
+//! aircircuit tag; [Function: zeros count (META), zero exprs, selectors
+//! start/end + width (META) | Memory: width (META)]; lookups count (META);
+//! per lookup: multiplicity expr, args count (META), arg exprs; then the 6
+//! circuit metadata fields (constraint_count, max_constraint_degree,
+//! preprocessed_height, preprocessed_width, stage_1_width, stage_2_width)
+//! (META).
+//!
+//! `degree_multiple` is NOT serialized: it is fully derivable (variables by
+//! entry kind, add/sub = max of children, mul = sum, neg = child) and the
+//! decoder recomputes it via the library's own `degree_multiple()` on the
+//! reconstructed children. Dropping it, the u32 enum tags, and the u64
+//! fixed-width scaffolding shrinks the kernel vk ~7x, which directly cuts the
+//! recursive verifier's dominant blake3 cost.
+//!
+//! Goldilocks note: constants are written as `as_canonical_u64()` (the raw
+//! internal repr is `pub(crate)` in `p3_goldilocks`) and read back with
+//! `from_u64`; verifying-key constants are canonical so the round-trip is
+//! exact, and the Lean reader reduces mod p regardless.
 
 // The codec is exercised by tests and wired to the FFI / Aiur port.
 #![allow(dead_code)]
@@ -51,146 +91,129 @@ use crate::{
 
 type Expr = SymbolicExpression<Val>;
 
+/// Sentinel for `None` in the preprocessed-index trailer.
+const NO_PREP_INDEX: u16 = u16::MAX;
+
 // ════════════════════════════════════════════════════════════════════════════
 // Encoder — System<AiurCircuit> -> bytes
 // ════════════════════════════════════════════════════════════════════════════
 
-struct W {
-  buf: Vec<u8>,
+/// One circuit's five segments, filled in record-content order.
+#[derive(Default)]
+struct RecordBufs {
+  tags: Vec<u8>,
+  idx: Vec<u8>,
+  c2: Vec<u8>,
+  c8: Vec<u8>,
+  meta: Vec<u8>,
 }
 
-impl W {
-  fn u8(&mut self, v: u8) {
-    self.buf.push(v);
+impl RecordBufs {
+  fn tag(&mut self, kind: u8, aux: u8) {
+    debug_assert!(kind < 16 && aux < 16);
+    self.tags.push(kind | (aux << 4));
   }
-  fn u32(&mut self, v: u32) {
-    self.buf.extend_from_slice(&v.to_le_bytes());
+  fn index_u16(&mut self, v: usize) {
+    let v = u16::try_from(v).expect("variable column index exceeds u16");
+    self.idx.extend_from_slice(&v.to_le_bytes());
   }
-  fn u64(&mut self, v: u64) {
-    self.buf.extend_from_slice(&v.to_le_bytes());
+  fn meta_u32(&mut self, v: usize) {
+    let v = u32::try_from(v).expect("vk metadata field exceeds u32");
+    self.meta.extend_from_slice(&v.to_le_bytes());
   }
-  fn usize(&mut self, v: usize) {
-    self.u64(v as u64);
-  }
-  fn g(&mut self, v: Val) {
-    // Goldilocks' raw repr is unreachable; the canonical value round-trips.
-    self.u64(v.as_canonical_u64());
-  }
-  fn entry(&mut self, e: &Entry) {
-    match *e {
-      Entry::Preprocessed { offset } => {
-        self.u32(0);
-        self.usize(offset);
-      },
-      Entry::Main { offset } => {
-        self.u32(1);
-        self.usize(offset);
-      },
-      Entry::Stage2 { offset } => {
-        self.u32(2);
-        self.usize(offset);
-      },
-      Entry::Public => self.u32(3),
-      Entry::Stage2Public => self.u32(4),
-      Entry::Challenge => self.u32(5),
+  fn constant(&mut self, v: Val) {
+    let c = v.as_canonical_u64();
+    if let Ok(c2) = u16::try_from(c) {
+      self.c2.extend_from_slice(&c2.to_le_bytes());
+      self.tag(4, 0);
+    } else {
+      self.c8.extend_from_slice(&c.to_le_bytes());
+      self.tag(4, 1);
     }
   }
+  fn variable(&mut self, v: &SymbolicVariable<Val>) {
+    let (kind, offset) = match v.entry {
+      Entry::Preprocessed { offset } => (0u8, offset),
+      Entry::Main { offset } => (1, offset),
+      Entry::Stage2 { offset } => (2, offset),
+      Entry::Public => (3, 0),
+      Entry::Stage2Public => (4, 0),
+      Entry::Challenge => (5, 0),
+    };
+    let offset = u8::try_from(offset).expect("rotation offset exceeds u8");
+    assert!(offset <= 1, "rotation offset {offset} not in {{0, 1}}");
+    self.tag(0, kind + 8 * offset);
+    self.index_u16(v.index);
+  }
   fn expr(&mut self, e: &Expr) {
     match e {
-      SymbolicExpression::Variable(v) => {
-        self.u32(0);
-        self.entry(&v.entry);
-        self.usize(v.index);
-      },
-      SymbolicExpression::IsFirstRow => self.u32(1),
-      SymbolicExpression::IsLastRow => self.u32(2),
-      SymbolicExpression::IsTransition => self.u32(3),
-      SymbolicExpression::Constant(c) => {
-        self.u32(4);
-        self.g(*c);
-      },
-      SymbolicExpression::Add { x, y, degree_multiple } => {
-        self.u32(5);
+      SymbolicExpression::Variable(v) => self.variable(v),
+      SymbolicExpression::IsFirstRow => self.tag(1, 0),
+      SymbolicExpression::IsLastRow => self.tag(2, 0),
+      SymbolicExpression::IsTransition => self.tag(3, 0),
+      SymbolicExpression::Constant(c) => self.constant(*c),
+      SymbolicExpression::Add { x, y, .. } => {
+        self.tag(5, 0);
         self.expr(x);
         self.expr(y);
-        self.usize(*degree_multiple);
       },
-      SymbolicExpression::Sub { x, y, degree_multiple } => {
-        self.u32(6);
+      SymbolicExpression::Sub { x, y, .. } => {
+        self.tag(6, 0);
         self.expr(x);
         self.expr(y);
-        self.usize(*degree_multiple);
       },
-      SymbolicExpression::Neg { x, degree_multiple } => {
-        self.u32(7);
+      SymbolicExpression::Neg { x, .. } => {
+        self.tag(7, 0);
         self.expr(x);
-        self.usize(*degree_multiple);
       },
-      SymbolicExpression::Mul { x, y, degree_multiple } => {
-        self.u32(8);
+      SymbolicExpression::Mul { x, y, .. } => {
+        self.tag(8, 0);
         self.expr(x);
         self.expr(y);
-        self.usize(*degree_multiple);
       },
     }
   }
-  fn vec<T>(&mut self, items: &[T], mut f: impl FnMut(&mut Self, &T)) {
-    self.usize(items.len());
-    for item in items {
-      f(self, item);
-    }
-  }
-  fn lookup(&mut self, l: &Lookup<Expr>) {
-    self.expr(&l.multiplicity);
-    self.vec(&l.args, Self::expr);
-  }
-  fn aircircuit(&mut self, c: &AiurCircuit) {
-    match c {
+  fn circuit(&mut self, c: &Circuit<AiurCircuit, Val>) {
+    match &c.air.inner_air {
       AiurCircuit::Function(Constraints { zeros, selectors, width }) => {
-        self.u32(0);
-        self.vec(zeros, Self::expr);
-        self.usize(selectors.start);
-        self.usize(selectors.end);
-        self.usize(*width);
+        self.tag(0, 0);
+        self.meta_u32(zeros.len());
+        for z in zeros {
+          self.expr(z);
+        }
+        self.meta_u32(selectors.start);
+        self.meta_u32(selectors.end);
+        self.meta_u32(*width);
       },
       AiurCircuit::Memory(Memory { width }) => {
-        self.u32(1);
-        self.usize(*width);
+        self.tag(1, 0);
+        self.meta_u32(*width);
       },
-      AiurCircuit::Bytes1 => self.u32(2),
-      AiurCircuit::Bytes2 => self.u32(3),
+      AiurCircuit::Bytes1 => self.tag(2, 0),
+      AiurCircuit::Bytes2 => self.tag(3, 0),
     }
-  }
-  fn circuit(&mut self, c: &Circuit<AiurCircuit, Val>) {
-    // LookupAir: inner_air, lookups (preprocessed is not serialized).
-    self.aircircuit(&c.air.inner_air);
-    self.vec(&c.air.lookups, Self::lookup);
-    self.usize(c.constraint_count);
-    self.usize(c.max_constraint_degree);
-    self.usize(c.preprocessed_height);
-    self.usize(c.preprocessed_width);
-    self.usize(c.stage_1_width);
-    self.usize(c.stage_2_width);
-  }
-  fn commitment(&mut self, c: &Commitment) {
-    // MerkleCap: Vec<[u8; 32]> Blake3 digests (raw bytes).
-    self.vec(c.roots(), |w, digest: &[u8; 32]| {
-      for &byte in digest {
-        w.u8(byte);
+    self.meta_u32(c.air.lookups.len());
+    for l in &c.air.lookups {
+      self.expr(&l.multiplicity);
+      self.meta_u32(l.args.len());
+      for a in &l.args {
+        self.expr(a);
       }
-    });
-  }
-  fn option<T>(&mut self, o: &Option<T>, f: impl FnOnce(&mut Self, &T)) {
-    match o {
-      None => self.u8(0),
-      Some(v) => {
-        self.u8(1);
-        f(self, v);
-      },
     }
+    self.meta_u32(c.constraint_count);
+    self.meta_u32(c.max_constraint_degree);
+    self.meta_u32(c.preprocessed_height);
+    self.meta_u32(c.preprocessed_width);
+    self.meta_u32(c.stage_1_width);
+    self.meta_u32(c.stage_2_width);
   }
 }
 
+fn push_u16(buf: &mut Vec<u8>, v: usize) {
+  let v = u16::try_from(v).expect("vk header field exceeds u16");
+  buf.extend_from_slice(&v.to_le_bytes());
+}
+
 /// Serialize the verifying key `System<AiurCircuit>` (preprocessed traces are
 /// skipped — see the module docs). The config's construction parameters are
 /// passed alongside because [`AiurConfig`] doesn't expose them back; they are
@@ -200,20 +223,50 @@ pub(crate) fn to_bytes(
   commitment_parameters: CommitmentParameters,
   fri_parameters: FriParameters,
 ) -> Vec<u8> {
-  let mut w = W { buf: Vec::new() };
-  w.usize(commitment_parameters.log_blowup);
-  w.usize(commitment_parameters.cap_height);
-  w.usize(fri_parameters.log_final_poly_len);
-  w.usize(fri_parameters.max_log_arity);
-  w.usize(fri_parameters.num_queries);
-  w.usize(fri_parameters.commit_proof_of_work_bits);
-  w.usize(fri_parameters.query_proof_of_work_bits);
-  w.vec(&system.circuits, W::circuit);
-  w.option(&system.preprocessed_commit, W::commitment);
-  w.vec(&system.preprocessed_indices, |w, idx| {
-    w.option(idx, |w, &i| w.usize(i))
-  });
-  w.buf
+  let mut buf = Vec::new();
+  push_u16(&mut buf, commitment_parameters.log_blowup);
+  push_u16(&mut buf, commitment_parameters.cap_height);
+  push_u16(&mut buf, fri_parameters.log_final_poly_len);
+  push_u16(&mut buf, fri_parameters.max_log_arity);
+  push_u16(&mut buf, fri_parameters.num_queries);
+  push_u16(&mut buf, fri_parameters.commit_proof_of_work_bits);
+  push_u16(&mut buf, fri_parameters.query_proof_of_work_bits);
+  push_u16(&mut buf, system.circuits.len());
+  for c in &system.circuits {
+    let mut r = RecordBufs::default();
+    r.circuit(c);
+    for seg in [&r.tags, &r.idx, &r.c2, &r.c8, &r.meta] {
+      let len = u32::try_from(seg.len()).expect("vk segment exceeds u32");
+      buf.extend_from_slice(&len.to_le_bytes());
+    }
+    for seg in [&r.tags, &r.idx, &r.c2, &r.c8, &r.meta] {
+      buf.extend_from_slice(seg);
+    }
+  }
+  match &system.preprocessed_commit {
+    None => buf.push(0),
+    Some(c) => {
+      buf.push(1);
+      push_u16(&mut buf, c.roots().len());
+      for digest in c.roots() {
+        buf.extend_from_slice(digest);
+      }
+    },
+  }
+  for idx in &system.preprocessed_indices {
+    match idx {
+      None => buf.extend_from_slice(&NO_PREP_INDEX.to_le_bytes()),
+      Some(i) => {
+        let v = u16::try_from(*i).expect("preprocessed index exceeds u16");
+        assert!(
+          v != NO_PREP_INDEX,
+          "preprocessed index collides with sentinel"
+        );
+        buf.extend_from_slice(&v.to_le_bytes());
+      },
+    }
+  }
+  buf
 }
 
 /// Convenience: serialize the verifying key of a built [`AiurSystem`].
@@ -227,14 +280,16 @@ pub fn aiur_system_to_bytes(sys: &AiurSystem) -> Result<Vec<u8>, String> {
 // A hand-written reader matching the bytes `to_bytes` produces, decoding
 // straight into the real `System<AiurCircuit>`. This is the reference
 // re-implemented in Aiur (`Ix/MultiStark/SystemDeserialize.lean`).
+// `degree_multiple` is recomputed from the reconstructed children.
 // ════════════════════════════════════════════════════════════════════════════
 
-struct R<'a> {
+/// Cursor over one byte region.
+struct Seg<'a> {
   buf: &'a [u8],
   pos: usize,
 }
 
-impl<'a> R<'a> {
+impl<'a> Seg<'a> {
   fn take(&mut self, n: usize) -> Result<&'a [u8], String> {
     let end = self.pos.checked_add(n).ok_or("length overflow")?;
     if end > self.buf.len() {
@@ -247,156 +302,211 @@ impl<'a> R<'a> {
   fn u8(&mut self) -> Result<u8, String> {
     Ok(self.take(1)?[0])
   }
+  fn u16(&mut self) -> Result<u16, String> {
+    Ok(u16::from_le_bytes(self.take(2)?.try_into().unwrap()))
+  }
   fn u32(&mut self) -> Result<u32, String> {
     Ok(u32::from_le_bytes(self.take(4)?.try_into().unwrap()))
   }
   fn u64(&mut self) -> Result<u64, String> {
     Ok(u64::from_le_bytes(self.take(8)?.try_into().unwrap()))
   }
-  fn usize(&mut self) -> Result<usize, String> {
-    usize::try_from(self.u64()?).map_err(|e| format!("usize overflow: {e}"))
-  }
-  fn g(&mut self) -> Result<Val, String> {
-    Ok(Val::from_u64(self.u64()?))
+  fn done(&self, what: &str) -> Result<(), String> {
+    if self.pos != self.buf.len() {
+      return Err(format!(
+        "{what}: consumed {} of {} bytes",
+        self.pos,
+        self.buf.len()
+      ));
+    }
+    Ok(())
   }
-  fn entry(&mut self) -> Result<Entry, String> {
-    Ok(match self.u32()? {
-      0 => Entry::Preprocessed { offset: self.usize()? },
-      1 => Entry::Main { offset: self.usize()? },
-      2 => Entry::Stage2 { offset: self.usize()? },
-      3 => Entry::Public,
-      4 => Entry::Stage2Public,
-      5 => Entry::Challenge,
-      t => return Err(format!("bad Entry tag {t}")),
-    })
+}
+
+/// One record's five segment cursors.
+struct RecordReader<'a> {
+  tags: Seg<'a>,
+  idx: Seg<'a>,
+  c2: Seg<'a>,
+  c8: Seg<'a>,
+  meta: Seg<'a>,
+}
+
+impl<'a> RecordReader<'a> {
+  fn meta_usize(&mut self) -> Result<usize, String> {
+    Ok(self.meta.u32()? as usize)
   }
   fn expr(&mut self) -> Result<Expr, String> {
-    Ok(match self.u32()? {
-      0 => SymbolicExpression::Variable(SymbolicVariable::new(
-        self.entry()?,
-        self.usize()?,
-      )),
+    let byte = self.tags.u8()?;
+    let (kind, aux) = (byte & 0xF, byte >> 4);
+    Ok(match kind {
+      0 => {
+        let offset = (aux >> 3) as usize;
+        let entry = match aux & 0x7 {
+          0 => Entry::Preprocessed { offset },
+          1 => Entry::Main { offset },
+          2 => Entry::Stage2 { offset },
+          3 => Entry::Public,
+          4 => Entry::Stage2Public,
+          5 => Entry::Challenge,
+          k => return Err(format!("bad entry kind {k}")),
+        };
+        let index = self.idx.u16()? as usize;
+        SymbolicExpression::Variable(SymbolicVariable::new(entry, index))
+      },
       1 => SymbolicExpression::IsFirstRow,
       2 => SymbolicExpression::IsLastRow,
       3 => SymbolicExpression::IsTransition,
-      4 => SymbolicExpression::Constant(self.g()?),
+      4 => {
+        let c = match aux {
+          0 => u64::from(self.c2.u16()?),
+          1 => self.c8.u64()?,
+          a => return Err(format!("bad constant size class {a}")),
+        };
+        SymbolicExpression::Constant(Val::from_u64(c))
+      },
       5 => {
         let x = Box::new(self.expr()?);
         let y = Box::new(self.expr()?);
-        SymbolicExpression::Add { x, y, degree_multiple: self.usize()? }
+        let degree_multiple = x.degree_multiple().max(y.degree_multiple());
+        SymbolicExpression::Add { x, y, degree_multiple }
       },
       6 => {
         let x = Box::new(self.expr()?);
         let y = Box::new(self.expr()?);
-        SymbolicExpression::Sub { x, y, degree_multiple: self.usize()? }
+        let degree_multiple = x.degree_multiple().max(y.degree_multiple());
+        SymbolicExpression::Sub { x, y, degree_multiple }
       },
       7 => {
         let x = Box::new(self.expr()?);
-        SymbolicExpression::Neg { x, degree_multiple: self.usize()? }
+        let degree_multiple = x.degree_multiple();
+        SymbolicExpression::Neg { x, degree_multiple }
       },
       8 => {
         let x = Box::new(self.expr()?);
         let y = Box::new(self.expr()?);
-        SymbolicExpression::Mul { x, y, degree_multiple: self.usize()? }
+        let degree_multiple = x.degree_multiple() + y.degree_multiple();
+        SymbolicExpression::Mul { x, y, degree_multiple }
       },
-      t => return Err(format!("bad SymbolicExpression tag {t}")),
+      t => return Err(format!("bad expr kind {t}")),
     })
   }
-  fn vec<T>(
-    &mut self,
-    mut f: impl FnMut(&mut Self) -> Result<T, String>,
-  ) -> Result<Vec<T>, String> {
-    let n = self.usize()?;
-    let mut v = Vec::with_capacity(n.min(1 << 16));
-    for _ in 0..n {
-      v.push(f(self)?);
-    }
-    Ok(v)
-  }
-  fn lookup(&mut self) -> Result<Lookup<Expr>, String> {
-    Ok(Lookup { multiplicity: self.expr()?, args: self.vec(Self::expr)? })
-  }
-  fn aircircuit(&mut self) -> Result<AiurCircuit, String> {
-    Ok(match self.u32()? {
-      0 => AiurCircuit::Function(Constraints {
-        zeros: self.vec(Self::expr)?,
-        selectors: self.usize()?..self.usize()?,
-        width: self.usize()?,
-      }),
-      1 => AiurCircuit::Memory(Memory { width: self.usize()? }),
+  fn circuit(&mut self) -> Result<Circuit<AiurCircuit, Val>, String> {
+    let inner_air = match self.tags.u8()? {
+      0 => {
+        let n = self.meta_usize()?;
+        let mut zeros = Vec::with_capacity(n.min(1 << 16));
+        for _ in 0..n {
+          zeros.push(self.expr()?);
+        }
+        let start = self.meta_usize()?;
+        let end = self.meta_usize()?;
+        let width = self.meta_usize()?;
+        AiurCircuit::Function(Constraints {
+          zeros,
+          selectors: start..end,
+          width,
+        })
+      },
+      1 => AiurCircuit::Memory(Memory { width: self.meta_usize()? }),
       2 => AiurCircuit::Bytes1,
       3 => AiurCircuit::Bytes2,
-      t => return Err(format!("bad AiurCircuit tag {t}")),
-    })
-  }
-  fn circuit(&mut self) -> Result<Circuit<AiurCircuit, Val>, String> {
-    // LookupAir: inner_air, lookups (preprocessed is prover-only -> None).
-    let air = LookupAir {
-      inner_air: self.aircircuit()?,
-      lookups: self.vec(Self::lookup)?,
-      preprocessed: None,
+      t => return Err(format!("bad aircircuit tag {t}")),
     };
-    Ok(Circuit {
-      air,
-      constraint_count: self.usize()?,
-      max_constraint_degree: self.usize()?,
-      preprocessed_height: self.usize()?,
-      preprocessed_width: self.usize()?,
-      stage_1_width: self.usize()?,
-      stage_2_width: self.usize()?,
-    })
-  }
-  fn commitment(&mut self) -> Result<Commitment, String> {
-    let caps = self.vec(|r| {
-      let mut d = [0u8; 32];
-      for b in d.iter_mut() {
-        *b = r.u8()?;
+    let n = self.meta_usize()?;
+    let mut lookups = Vec::with_capacity(n.min(1 << 16));
+    for _ in 0..n {
+      let multiplicity = self.expr()?;
+      let a = self.meta_usize()?;
+      let mut args = Vec::with_capacity(a.min(1 << 16));
+      for _ in 0..a {
+        args.push(self.expr()?);
       }
-      Ok(d)
-    })?;
-    Ok(Commitment::from(caps))
-  }
-  fn option<T>(
-    &mut self,
-    f: impl FnOnce(&mut Self) -> Result<T, String>,
-  ) -> Result<Option<T>, String> {
-    match self.u8()? {
-      0 => Ok(None),
-      1 => Ok(Some(f(self)?)),
-      t => Err(format!("bad Option tag {t}")),
+      lookups.push(Lookup { multiplicity, args });
     }
+    let air = LookupAir { inner_air, lookups, preprocessed: None };
+    let c = Circuit {
+      air,
+      constraint_count: self.meta_usize()?,
+      max_constraint_degree: self.meta_usize()?,
+      preprocessed_height: self.meta_usize()?,
+      preprocessed_width: self.meta_usize()?,
+      stage_1_width: self.meta_usize()?,
+      stage_2_width: self.meta_usize()?,
+    };
+    self.tags.done("TAGS segment")?;
+    self.idx.done("IDX segment")?;
+    self.c2.done("C2 segment")?;
+    self.c8.done("C8 segment")?;
+    self.meta.done("META segment")?;
+    Ok(c)
   }
 }
 
 /// Deserialize a `System<AiurCircuit>` from [`to_bytes`] output, requiring that
-/// every byte is consumed. Also returns the config's construction parameters,
-/// which the `System` itself doesn't expose.
+/// every byte (globally and within each record segment) is consumed. Also
+/// returns the config's construction parameters, which the `System` itself
+/// doesn't expose.
 pub(crate) fn from_bytes(
   bytes: &[u8],
 ) -> Result<
   (System<AiurConfig, AiurCircuit>, CommitmentParameters, FriParameters),
   String,
 > {
-  let mut r = R { buf: bytes, pos: 0 };
-  let commitment_parameters =
-    CommitmentParameters { log_blowup: r.usize()?, cap_height: r.usize()? };
+  let mut r = Seg { buf: bytes, pos: 0 };
+  let commitment_parameters = CommitmentParameters {
+    log_blowup: r.u16()? as usize,
+    cap_height: r.u16()? as usize,
+  };
   let fri_parameters = FriParameters {
-    log_final_poly_len: r.usize()?,
-    max_log_arity: r.usize()?,
-    num_queries: r.usize()?,
-    commit_proof_of_work_bits: r.usize()?,
-    query_proof_of_work_bits: r.usize()?,
+    log_final_poly_len: r.u16()? as usize,
+    max_log_arity: r.u16()? as usize,
+    num_queries: r.u16()? as usize,
+    commit_proof_of_work_bits: r.u16()? as usize,
+    query_proof_of_work_bits: r.u16()? as usize,
   };
-  let circuits = r.vec(R::circuit)?;
-  let preprocessed_commit = r.option(R::commitment)?;
-  let preprocessed_indices = r.vec(|r| r.option(R::usize))?;
-  if r.pos != bytes.len() {
-    return Err(format!(
-      "trailing data: consumed {} of {}",
-      r.pos,
-      bytes.len()
-    ));
+  let n_circuits = r.u16()? as usize;
+  let mut circuits = Vec::with_capacity(n_circuits);
+  for _ in 0..n_circuits {
+    let lens: [usize; 5] = [
+      r.u32()? as usize,
+      r.u32()? as usize,
+      r.u32()? as usize,
+      r.u32()? as usize,
+      r.u32()? as usize,
+    ];
+    let tags = Seg { buf: r.take(lens[0])?, pos: 0 };
+    let idx = Seg { buf: r.take(lens[1])?, pos: 0 };
+    let c2 = Seg { buf: r.take(lens[2])?, pos: 0 };
+    let c8 = Seg { buf: r.take(lens[3])?, pos: 0 };
+    let meta = Seg { buf: r.take(lens[4])?, pos: 0 };
+    let mut rec = RecordReader { tags, idx, c2, c8, meta };
+    circuits.push(rec.circuit()?);
   }
+  let preprocessed_commit = match r.u8()? {
+    0 => None,
+    1 => {
+      let n = r.u16()? as usize;
+      let mut caps = Vec::with_capacity(n.min(1 << 16));
+      for _ in 0..n {
+        let mut d = [0u8; 32];
+        d.copy_from_slice(r.take(32)?);
+        caps.push(d);
+      }
+      Some(Commitment::from(caps))
+    },
+    t => return Err(format!("bad Option tag {t}")),
+  };
+  let mut preprocessed_indices = Vec::with_capacity(n_circuits);
+  for _ in 0..n_circuits {
+    let v = r.u16()?;
+    preprocessed_indices.push(if v == NO_PREP_INDEX {
+      None
+    } else {
+      Some(v as usize)
+    });
+  }
+  r.done("vk")?;
   let system = System {
     config: AiurConfig::new(commitment_parameters, fri_parameters),
     circuits,
@@ -424,11 +534,8 @@ mod tests {
     (cp, fp)
   }
 
-  /// Build a small real `System<AiurCircuit>` from the two byte gadgets and
-  /// check the verifying-key codec round-trips: decode(encode(x)) re-encodes to
-  /// the same bytes (a serialization fixpoint).
-  #[test]
-  fn system_vk_round_trips() {
+  fn test_system()
+  -> (System<AiurConfig, AiurCircuit>, CommitmentParameters, FriParameters) {
     let (cp, fp) = test_parameters();
     let (system, _key) = System::new(
       AiurConfig::new(cp, fp),
@@ -437,21 +544,86 @@ mod tests {
         LookupAir::new(AiurCircuit::Bytes2, Bytes2.lookups()),
       ],
     );
+    (system, cp, fp)
+  }
+
+  /// Structural equality of expressions INCLUDING the recomputed
+  /// `degree_multiple` — validates the decoder's degree reconstruction
+  /// node by node.
+  fn expr_eq(a: &Expr, b: &Expr) -> bool {
+    use SymbolicExpression as E;
+    if a.degree_multiple() != b.degree_multiple() {
+      return false;
+    }
+    match (a, b) {
+      (E::Variable(u), E::Variable(v)) => {
+        u.entry == v.entry && u.index == v.index
+      },
+      (E::IsFirstRow, E::IsFirstRow)
+      | (E::IsLastRow, E::IsLastRow)
+      | (E::IsTransition, E::IsTransition) => true,
+      (E::Constant(c), E::Constant(d)) => c == d,
+      (E::Add { x: ax, y: ay, .. }, E::Add { x: bx, y: by, .. })
+      | (E::Sub { x: ax, y: ay, .. }, E::Sub { x: bx, y: by, .. })
+      | (E::Mul { x: ax, y: ay, .. }, E::Mul { x: bx, y: by, .. }) => {
+        expr_eq(ax, bx) && expr_eq(ay, by)
+      },
+      (E::Neg { x: ax, .. }, E::Neg { x: bx, .. }) => expr_eq(ax, bx),
+      _ => false,
+    }
+  }
+
+  /// Round-trip: decode(encode(x)) re-encodes to the same bytes AND every
+  /// expression (with its recomputed degrees) matches the original.
+  #[test]
+  fn system_vk_round_trips() {
+    let (system, cp, fp) = test_system();
     let bytes = to_bytes(&system, cp, fp);
     let (back, back_cp, back_fp) = from_bytes(&bytes).expect("decode");
     let reencoded = to_bytes(&back, back_cp, back_fp);
     assert_eq!(bytes, reencoded, "verifying-key codec round-trip mismatch");
+    assert_eq!(system.circuits.len(), back.circuits.len());
+    for (a, b) in system.circuits.iter().zip(&back.circuits) {
+      assert_eq!(a.air.lookups.len(), b.air.lookups.len());
+      for (la, lb) in a.air.lookups.iter().zip(&b.air.lookups) {
+        assert!(
+          expr_eq(&la.multiplicity, &lb.multiplicity),
+          "lookup multiplicity mismatch (degree recomputation?)"
+        );
+        assert_eq!(la.args.len(), lb.args.len());
+        for (ea, eb) in la.args.iter().zip(&lb.args) {
+          assert!(expr_eq(ea, eb), "lookup arg mismatch");
+        }
+      }
+      if let (AiurCircuit::Function(fa), AiurCircuit::Function(fb)) =
+        (&a.air.inner_air, &b.air.inner_air)
+      {
+        assert_eq!(fa.zeros.len(), fb.zeros.len());
+        for (ea, eb) in fa.zeros.iter().zip(&fb.zeros) {
+          assert!(expr_eq(ea, eb), "constraint mismatch");
+        }
+      }
+    }
   }
 
   #[test]
   fn rejects_trailing_bytes() {
-    let (cp, fp) = test_parameters();
-    let (system, _key) = System::new(
-      AiurConfig::new(cp, fp),
-      [LookupAir::new(AiurCircuit::Bytes1, Bytes1.lookups())],
-    );
+    let (system, cp, fp) = test_system();
     let mut bytes = to_bytes(&system, cp, fp);
     bytes.push(0);
     assert!(from_bytes(&bytes).is_err(), "should reject trailing data");
   }
+
+  /// A tampered segment length must be rejected (the record readers enforce
+  /// exact per-segment consumption).
+  #[test]
+  fn rejects_bad_segment_length() {
+    let (system, cp, fp) = test_system();
+    let mut bytes = to_bytes(&system, cp, fp);
+    // First record header starts right after the 16-byte global header;
+    // bump the TAGS segment length by one.
+    let tags_len = u32::from_le_bytes(bytes[16..20].try_into().unwrap());
+    bytes[16..20].copy_from_slice(&(tags_len + 1).to_le_bytes());
+    assert!(from_bytes(&bytes).is_err(), "should reject bad segment length");
+  }
 }
diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs
index 63163d547..e0d561968 100644
--- a/crates/ffi/src/aiur/protocol.rs
+++ b/crates/ffi/src/aiur/protocol.rs
@@ -649,6 +649,99 @@ extern "C" fn rs_aiur_system_prove_ixvm(
   result.into()
 }
 
+/// `Bytecode.Toplevel.executeMultiStark`: run the MultiStark recursive
+/// verifier over raw proof/vk/claims byte blobs. The IO advice buffer
+/// (channel 0 = proof, 1 = vk, 2 = claims, key `[0]` each) is built
+/// natively via `verifier_io_buffer` — no per-byte Lean boxing, no
+/// buffer marshalling across FFI. `use_bytecode` selects the executor:
+/// `false` = codegen'd verifier (`execute_multi_stark`),
+/// `true`  = generic Aiur bytecode interpreter.
+/// Returns `(output, query_counts)`; the final buffer is not returned
+/// (the verifier only reads its advice).
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_multi_stark_execute(
+  toplevel: LeanAiurToplevel<LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  pub_input: LeanArray<LeanBorrowed<'_>>,
+  proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  use_bytecode: bool,
+) -> LeanExcept<LeanOwned> {
+  let toplevel = decode_toplevel(&toplevel);
+  let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let mut io_buffer = ixvm_codegen::aiur_multi_stark_runner::verifier_io_buffer(
+    proof_bytes.as_bytes(),
+    vk_bytes.as_bytes(),
+    claims_bytes.as_bytes(),
+  );
+  let input = pub_input.map(|x| lean_unbox_g(&x));
+
+  // Same execution-phase span as the prove pipeline.
+  let _g = tracing::info_span!("aiur/execute_multi_stark").entered();
+  let result = if use_bytecode {
+    toplevel.execute(fun_idx, input, &mut io_buffer)
+  } else {
+    ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark(
+      &toplevel,
+      fun_idx,
+      input,
+      &mut io_buffer,
+    )
+  };
+  let (query_record, output) = match result {
+    Ok(pair) => pair,
+    Err(err) => return LeanExcept::error_string(&err.to_string()),
+  };
+
+  let lean_query_counts = build_query_counts_array(&query_record, &toplevel);
+  // (Array G, Array (Nat × Nat))
+  let result = LeanProd::new(build_g_array(&output), lean_query_counts);
+  LeanExcept::ok(result)
+}
+
+/// `AiurSystem.proveMultiStark`: prove the MultiStark recursive
+/// verifier over raw proof/vk/claims byte blobs. Buffer construction
+/// and executor selection as in `rs_aiur_multi_stark_execute`; the
+/// prove itself reuses the executor-generic `AiurSystem::prove_ixvm`.
+/// Returns `(claim, proof)`; the final buffer is not returned.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_multi_stark_prove(
+  aiur_system_obj: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  pub_input: LeanArray<LeanBorrowed<'_>>,
+  proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  use_bytecode: bool,
+) -> LeanOwned {
+  let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let mut io_buffer = ixvm_codegen::aiur_multi_stark_runner::verifier_io_buffer(
+    proof_bytes.as_bytes(),
+    vk_bytes.as_bytes(),
+    claims_bytes.as_bytes(),
+  );
+  let args = pub_input.map(|x| lean_unbox_g(&x));
+
+  let system = aiur_system_obj.get();
+  let (claim, proof) = if use_bytecode {
+    system.prove(fun_idx, &args, &mut io_buffer)
+  } else {
+    system.prove_ixvm(
+      fun_idx,
+      &args,
+      &mut io_buffer,
+      ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark,
+    )
+  };
+
+  let lean_proof: LeanOwned =
+    LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into();
+  // Array G × Proof
+  let result = LeanProd::new(build_g_array(&claim), lean_proof);
+  result.into()
+}
+
 // =============================================================================
 // Helpers
 // =============================================================================
diff --git a/crates/ffi/src/aiur/toplevel.rs b/crates/ffi/src/aiur/toplevel.rs
index bb9cdfdf8..73124cb92 100644
--- a/crates/ffi/src/aiur/toplevel.rs
+++ b/crates/ffi/src/aiur/toplevel.rs
@@ -158,6 +158,14 @@ fn decode_op(ctor: LeanCtor<LeanBorrowed<'_>>) -> Op {
       let [i, j] = ctor.objs::<2>().map(|x| lean_unbox_nat_as_usize(&x));
       Op::UnconstrainedBigUintDivMod(i, j)
     },
+    29 => {
+      let [a] = ctor.objs::<1>().map(|x| lean_unbox_nat_as_usize(&x));
+      Op::UnconstrainedGToBytes(a)
+    },
+    30 => {
+      let [a] = ctor.objs::<1>().map(|x| lean_unbox_nat_as_usize(&x));
+      Op::UnconstrainedGInverse(a)
+    },
     _ => unreachable!(),
   }
 }
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index a753a6ac0..6575081ed 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -1532,8 +1532,8 @@ fn aiur_fn_4(
   })
 }
 
-const INPUT_SIZE_5: usize = 8;
-const IN_5: usize = 8;
+const INPUT_SIZE_5: usize = 4;
+const IN_5: usize = 4;
 const OUT_5: usize = 4;
 fn aiur_fn_5(
   inp: [G; IN_5],
@@ -1546,15 +1546,7 @@ fn aiur_fn_5(
     let __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 = if unconstrained { Bytes2::and(&__v_0, &__v_4) } else { bytes2_and_value(__v_0, __v_4, record) };
-    let __v_9: G = if unconstrained { Bytes2::and(&__v_1, &__v_5) } else { bytes2_and_value(__v_1, __v_5, record) };
-    let __v_10: G = if unconstrained { Bytes2::and(&__v_2, &__v_6) } else { bytes2_and_value(__v_2, __v_6, record) };
-    let __v_11: G = if unconstrained { Bytes2::and(&__v_3, &__v_7) } else { bytes2_and_value(__v_3, __v_7, record) };
-    let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11];
+    let __ret: [G; OUT_5] = [__v_2, __v_3, __v_0, __v_1];
     record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -1574,7 +1566,7 @@ fn aiur_fn_6(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_6] = [__v_2, __v_3, __v_0, __v_1];
+    let __ret: [G; OUT_6] = [__v_1, __v_2, __v_3, __v_0];
     record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -1589,26 +1581,6 @@ fn aiur_fn_7(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> 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_7] = [__v_1, __v_2, __v_3, __v_0];
-    record.function_queries[7].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],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
@@ -1624,21 +1596,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_7] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_9: usize = 4;
-const IN_9: usize = 4;
-const OUT_9: usize = 4;
-fn aiur_fn_9(
-  inp: [G; IN_9],
+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_9], 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];
@@ -1654,21 +1626,21 @@ fn aiur_fn_9(
     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_9] = [__v_4, __v_10, __v_7, __v_11];
-    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_8] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[8].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 = 1;
-fn aiur_fn_10(
-  inp: [G; IN_10],
+const INPUT_SIZE_9: usize = 16;
+const IN_9: usize = 16;
+const OUT_9: usize = 1;
+fn aiur_fn_9(
+  inp: [G; IN_9],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_10], 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];
@@ -1711,85 +1683,85 @@ fn aiur_fn_10(
                                 match __v_23.as_canonical_u64() {
                                   0u64 => {
                                     let __v_24: G = G::from_u64(1);
-                                    let __ret: [G; OUT_10] = [__v_24];
-                                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_9] = [__v_24];
+                                    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_24: G = G::from_u64(0);
-                                    let __ret: [G; OUT_10] = [__v_24];
-                                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_9] = [__v_24];
+                                    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_24: G = G::from_u64(0);
-                                let __ret: [G; OUT_10] = [__v_24];
-                                record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_9] = [__v_24];
+                                record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_24: G = G::from_u64(0);
-                            let __ret: [G; OUT_10] = [__v_24];
-                            record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_9] = [__v_24];
+                            record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_24: G = G::from_u64(0);
-                        let __ret: [G; OUT_10] = [__v_24];
-                        record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_9] = [__v_24];
+                        record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_24: G = G::from_u64(0);
-                    let __ret: [G; OUT_10] = [__v_24];
-                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_9] = [__v_24];
+                    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_24: G = G::from_u64(0);
-                let __ret: [G; OUT_10] = [__v_24];
-                record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_9] = [__v_24];
+                record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(0);
-            let __ret: [G; OUT_10] = [__v_24];
-            record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_9] = [__v_24];
+            record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_24: G = G::from_u64(0);
-        let __ret: [G; OUT_10] = [__v_24];
-        record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_9] = [__v_24];
+        record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_11: usize = 16;
-const IN_11: usize = 16;
-const OUT_11: usize = 9;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+const INPUT_SIZE_10: usize = 16;
+const IN_10: usize = 16;
+const OUT_10: usize = 9;
+fn aiur_fn_10(
+  inp: [G; IN_10],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_11], 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];
@@ -1859,133 +1831,21 @@ fn aiur_fn_11(
     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_11] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_12: usize = 16;
-const IN_12: usize = 16;
-const OUT_12: usize = 8;
-fn aiur_fn_12(
-  inp: [G; IN_12],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_12], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __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_2] = { let __args: [G; IN_2] = [__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[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_16: G = __r_arr[0];
-    match __v_16.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_12] = [__v_0, __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));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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 __v_17: G = __r_arr[0];
-        let __v_18: G = __r_arr[1];
-        let __v_19: G = __r_arr[2];
-        let __v_20: G = __r_arr[3];
-        let __v_21: G = __r_arr[4];
-        let __v_22: G = __r_arr[5];
-        let __v_23: G = __r_arr[6];
-        let __v_24: G = __r_arr[7];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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 __v_25: G = __r_arr[0];
-        let __v_26: G = __r_arr[1];
-        let __v_27: G = __r_arr[2];
-        let __v_28: G = __r_arr[3];
-        let __v_29: G = __r_arr[4];
-        let __v_30: G = __r_arr[5];
-        let __v_31: G = __r_arr[6];
-        let __v_32: G = __r_arr[7];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_17, __v_18, __v_19, __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[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_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 = __r_arr[6];
-        let __v_40: G = __r_arr[7];
-        let __ret: [G; OUT_12] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
-        record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_13: usize = 2;
-const IN_13: usize = 2;
-const OUT_13: usize = 1;
-fn aiur_fn_13(
-  inp: [G; IN_13],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_13], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_13] = [__v_2];
-            record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_13] = [__v_2];
-            record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_13] = [__v_2];
-        record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_14: usize = 8;
-const IN_14: usize = 8;
-const OUT_14: usize = 8;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 8;
+fn aiur_fn_11(
+  inp: [G; IN_11],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], 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];
@@ -2019,8 +1879,8 @@ fn aiur_fn_14(
                                     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_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));
+                                    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));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2033,8 +1893,8 @@ fn aiur_fn_14(
                                     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_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));
+                                    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));
                                     return Ok(__ret);
                                   },
                                 }
@@ -2048,8 +1908,8 @@ fn aiur_fn_14(
                                 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_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));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -2062,8 +1922,8 @@ fn aiur_fn_14(
                             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_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));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -2075,8 +1935,8 @@ fn aiur_fn_14(
                         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_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));
+                        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));
                         return Ok(__ret);
                       },
                     }
@@ -2087,8 +1947,8 @@ fn aiur_fn_14(
                     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_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));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -2098,8 +1958,8 @@ fn aiur_fn_14(
                 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_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));
+                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));
                 return Ok(__ret);
               },
             }
@@ -2108,8 +1968,8 @@ fn aiur_fn_14(
             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_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));
+            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));
             return Ok(__ret);
           },
         }
@@ -2117,124 +1977,23 @@ fn aiur_fn_14(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 + __v_8);
-        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));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_15: usize = 10;
-const IN_15: usize = 10;
-const OUT_15: usize = 8;
-fn aiur_fn_15(
-  inp: [G; IN_15],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __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 __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_7, &__v_9) } else { bytes2_add_value(__v_7, __v_9, record) };
-    let __v_10: G = __b2_add.0;
-    let __v_11: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_6, &__v_8) } else { bytes2_add_value(__v_6, __v_8, record) };
-    let __v_12: G = __b2_add.0;
-    let __v_13: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_12, &__v_11) } else { bytes2_add_value(__v_12, __v_11, record) };
-    let __v_14: G = __b2_add.0;
-    let __v_15: G = __b2_add.1;
-    let __v_16: G = (__v_13 + __v_15);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_5, &__v_16) } else { bytes2_add_value(__v_5, __v_16, record) };
-    let __v_17: G = __b2_add.0;
-    let __v_18: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_4, &__v_18) } else { bytes2_add_value(__v_4, __v_18, record) };
-    let __v_19: G = __b2_add.0;
-    let __v_20: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_20) } else { bytes2_add_value(__v_3, __v_20, record) };
-    let __v_21: G = __b2_add.0;
-    let __v_22: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_22) } else { bytes2_add_value(__v_2, __v_22, record) };
-    let __v_23: G = __b2_add.0;
-    let __v_24: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_24) } else { bytes2_add_value(__v_1, __v_24, record) };
-    let __v_25: G = __b2_add.0;
-    let __v_26: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_26) } else { bytes2_add_value(__v_0, __v_26, record) };
-    let __v_27: G = __b2_add.0;
-    let __v_28: G = __b2_add.1;
-    let __ret: [G; OUT_15] = [__v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_12, __v_10];
-    record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_16: usize = 8;
-const IN_16: usize = 8;
-const OUT_16: usize = 4;
-fn aiur_fn_16(
-  inp: [G; IN_16],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_16], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = 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 __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) };
-    let __v_8: G = __b2_add.0;
-    let __v_9: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) };
-    let __v_10: G = __b2_add.0;
-    let __v_11: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_9) } else { bytes2_add_value(__v_10, __v_9, record) };
-    let __v_12: G = __b2_add.0;
-    let __v_13: G = __b2_add.1;
-    let __v_14: G = (__v_11 + __v_13);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) };
-    let __v_15: G = __b2_add.0;
-    let __v_16: G = __b2_add.1;
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_15, &__v_14) } else { bytes2_add_value(__v_15, __v_14, record) };
-    let __v_17: G = __b2_add.0;
-    let __v_18: G = __b2_add.1;
-    let __v_19: G = (__v_16 + __v_18);
-    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) };
-    let __v_20: G = __b2_add.0;
-    let __v_21: G = __b2_add.1;
-    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_16] = [__v_22, __v_17, __v_12, __v_8];
-    record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_17: usize = 8;
-const IN_17: usize = 8;
-const OUT_17: usize = 8;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_12: usize = 8;
+const IN_12: usize = 8;
+const OUT_12: usize = 8;
+fn aiur_fn_12(
+  inp: [G; IN_12],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], 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];
@@ -2268,8 +2027,8 @@ fn aiur_fn_17(
                                     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_17] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2282,8 +2041,8 @@ fn aiur_fn_17(
                                     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_17] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                 }
@@ -2297,8 +2056,8 @@ fn aiur_fn_17(
                                 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_17] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -2311,8 +2070,8 @@ fn aiur_fn_17(
                             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_17] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -2324,8 +2083,8 @@ fn aiur_fn_17(
                         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_17] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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));
                         return Ok(__ret);
                       },
                     }
@@ -2336,8 +2095,8 @@ fn aiur_fn_17(
                     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_17] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -2347,8 +2106,8 @@ fn aiur_fn_17(
                 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_17] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -2357,8 +2116,8 @@ fn aiur_fn_17(
             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_17] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -2366,23 +2125,23 @@ fn aiur_fn_17(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 - __v_8);
-        let __ret: [G; OUT_17] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_18: usize = 8;
-const IN_18: usize = 8;
-const OUT_18: usize = 1;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_13: usize = 8;
+const IN_13: usize = 8;
+const OUT_13: usize = 1;
+fn aiur_fn_13(
+  inp: [G; IN_13],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], 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];
@@ -2414,149 +2173,21 @@ fn aiur_fn_18(
     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_18] = [__v_26];
-    record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_13] = [__v_26];
+    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 0;
-const IN_19: usize = 0;
-const OUT_19: usize = 32;
-fn aiur_fn_19(
-  inp: [G; IN_19],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_19], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(0);
-    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_1]; let __info = io_buffer.get_info(__v_0, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_2: G = __io_pair.0;
-    let __v_3: G = __io_pair.1;
-    let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2, __v_3]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__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_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __v_8: G = __r_arr[2];
-    let __v_9: G = __r_arr[3];
-    let __v_10: G = __r_arr[4];
-    let __v_11: G = __r_arr[5];
-    let __v_12: G = __r_arr[6];
-    let __v_13: G = __r_arr[7];
-    let __v_14: G = __r_arr[8];
-    let __v_15: G = __r_arr[9];
-    let __v_16: G = __r_arr[10];
-    let __v_17: G = __r_arr[11];
-    let __v_18: G = __r_arr[12];
-    let __v_19: G = __r_arr[13];
-    let __v_20: G = __r_arr[14];
-    let __v_21: G = __r_arr[15];
-    let __v_22: G = __r_arr[16];
-    let __v_23: G = __r_arr[17];
-    let __v_24: G = __r_arr[18];
-    let __v_25: G = __r_arr[19];
-    let __v_26: G = __r_arr[20];
-    let __v_27: G = __r_arr[21];
-    let __v_28: G = __r_arr[22];
-    let __v_29: G = __r_arr[23];
-    let __v_30: G = __r_arr[24];
-    let __v_31: G = __r_arr[25];
-    let __v_32: G = __r_arr[26];
-    let __v_33: G = __r_arr[27];
-    let __v_34: G = __r_arr[28];
-    let __v_35: G = __r_arr[29];
-    let __v_36: G = __r_arr[30];
-    let __v_37: G = __r_arr[31];
-    let __ret: [G; OUT_19] = [__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];
-    record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_20: usize = 1;
-const IN_20: usize = 1;
-const OUT_20: usize = 1;
-fn aiur_fn_20(
-  inp: [G; IN_20],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_20], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = (__v_0 - __v_1);
-    let __v_3: G = G::from_u64(0);
-    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_4: G = __io_pair.0;
-    let __v_5: G = __io_pair.1;
-    let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; 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_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 __v_20: G = __r_arr[12];
-    let __v_21: G = __r_arr[13];
-    let __v_22: G = __r_arr[14];
-    let __v_23: G = __r_arr[15];
-    let __v_24: G = __r_arr[16];
-    let __v_25: G = __r_arr[17];
-    let __v_26: G = __r_arr[18];
-    let __v_27: G = __r_arr[19];
-    let __v_28: G = __r_arr[20];
-    let __v_29: G = __r_arr[21];
-    let __v_30: G = __r_arr[22];
-    let __v_31: G = __r_arr[23];
-    let __v_32: G = __r_arr[24];
-    let __v_33: G = __r_arr[25];
-    let __v_34: G = __r_arr[26];
-    let __v_35: G = __r_arr[27];
-    let __v_36: G = __r_arr[28];
-    let __v_37: G = __r_arr[29];
-    let __v_38: G = __r_arr[30];
-    let __v_39: G = __r_arr[31];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_40: G = G::from_u64(0);
-        let __ret: [G; OUT_20] = [__v_40];
-        record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_2]; 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_40: G = __r_arr[0];
-        let __ret: [G; OUT_20] = [__v_40];
-        record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_21: usize = 1;
-const IN_21: usize = 1;
-const OUT_21: usize = 32;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_14: usize = 1;
+const IN_14: usize = 1;
+const OUT_14: usize = 32;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_21], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -2609,7 +2240,7 @@ fn aiur_fn_21(
     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_26] = { let __args: [G; IN_26] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; 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_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 __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];
@@ -2646,7 +2277,7 @@ fn aiur_fn_21(
     let __v_83: G = __loaded[31];
     let __v_84: G = __loaded[32];
     let __v_85: G = __loaded[33];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__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[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_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 __v_86: G = __r_arr[0];
     let __v_87: G = __r_arr[1];
     let __v_88: G = __r_arr[2];
@@ -2679,21 +2310,21 @@ fn aiur_fn_21(
     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_21] = [__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[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_22: usize = 33;
-const IN_22: usize = 33;
-const OUT_22: usize = 0;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_15: usize = 33;
+const IN_15: usize = 33;
+const OUT_15: usize = 0;
+fn aiur_fn_15(
+  inp: [G; IN_15],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], 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];
@@ -2728,7 +2359,7 @@ fn aiur_fn_22(
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0]; 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_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 __v_33: G = __r_arr[0];
     let __v_34: G = __r_arr[1];
     let __v_35: G = __r_arr[2];
@@ -2857,24 +2488,24 @@ fn aiur_fn_22(
     if (__v_64 != __v_32) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
     }
-    let __ret: [G; OUT_22] = [];
-    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_15] = [];
+    record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 1;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_16: usize = 1;
+const IN_16: usize = 1;
+const OUT_16: usize = 1;
+fn aiur_fn_16(
+  inp: [G; IN_16],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0]; 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_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -2908,21 +2539,21 @@ fn aiur_fn_23(
     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_23] = [__v_33];
-    record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_16] = [__v_33];
+    record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_24: usize = 67;
-const IN_24: usize = 67;
-const OUT_24: usize = 67;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_17: usize = 67;
+const IN_17: usize = 67;
+const OUT_17: usize = 67;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], 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];
@@ -2996,8 +2627,8 @@ fn aiur_fn_24(
         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_24] = [__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[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -3037,7 +2668,7 @@ fn aiur_fn_24(
         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_24] = { let __args: [G; IN_24] = [__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[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_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 __v_102: G = __r_arr[0];
         let __v_103: G = __r_arr[1];
         let __v_104: G = __r_arr[2];
@@ -3108,8 +2739,8 @@ fn aiur_fn_24(
         match __v_102.as_canonical_u64() {
           0u64 => {
             let __v_169: G = G::from_u64(1);
-            let __ret: [G; OUT_24] = [__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[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           1u64 => {
@@ -3160,7 +2791,7 @@ fn aiur_fn_24(
                 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_33] = { let __args: [G; IN_33] = [__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[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_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 __v_214: G = __r_arr[0];
                 let __v_215: G = __r_arr[1];
                 let __v_216: G = __r_arr[2];
@@ -3197,8 +2828,8 @@ fn aiur_fn_24(
                 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_24] = [__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[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -3211,7 +2842,7 @@ fn aiur_fn_24(
                 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_33] = { let __args: [G; IN_33] = [__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[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_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 __v_212: G = __r_arr[0];
                 let __v_213: G = __r_arr[1];
                 let __v_214: G = __r_arr[2];
@@ -3248,8 +2879,8 @@ fn aiur_fn_24(
                 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_24] = [__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[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -3266,15 +2897,15 @@ fn aiur_fn_24(
   })
 }
 
-const INPUT_SIZE_25: usize = 34;
-const IN_25: usize = 34;
-const OUT_25: usize = 32;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_18: usize = 34;
+const IN_18: usize = 34;
+const OUT_18: usize = 32;
+fn aiur_fn_18(
+  inp: [G; IN_18],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], ExecError> {
+) -> Result<[G; OUT_18], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -3349,8 +2980,8 @@ fn aiur_fn_25(
         let __v_67: G = __loaded[33];
         match __v_34.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_25] = [__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[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -3390,7 +3021,7 @@ fn aiur_fn_25(
             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_24] = { let __args: [G; IN_24] = [__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[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_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 __v_103: G = __r_arr[0];
             let __v_104: G = __r_arr[1];
             let __v_105: G = __r_arr[2];
@@ -3460,7 +3091,7 @@ fn aiur_fn_25(
             let __v_169: G = __r_arr[66];
             match __v_103.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__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[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_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 __v_170: G = __r_arr[0];
                 let __v_171: G = __r_arr[1];
                 let __v_172: G = __r_arr[2];
@@ -3493,14 +3124,14 @@ fn aiur_fn_25(
                 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_25] = [__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[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 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_25] = { let __args: [G; IN_25] = [__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[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_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 __v_172: G = __r_arr[0];
                 let __v_173: G = __r_arr[1];
                 let __v_174: G = __r_arr[2];
@@ -3533,8 +3164,8 @@ fn aiur_fn_25(
                 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_25] = [__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[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -3551,15 +3182,15 @@ fn aiur_fn_25(
   })
 }
 
-const INPUT_SIZE_26: usize = 7;
-const IN_26: usize = 7;
-const OUT_26: usize = 1;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_19: usize = 7;
+const IN_19: usize = 7;
+const OUT_19: usize = 1;
+fn aiur_fn_19(
+  inp: [G; IN_19],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], 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];
@@ -3574,10 +3205,10 @@ fn aiur_fn_26(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_26] = [__v_10];
-        record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_19] = [__v_10];
+        record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -3585,10 +3216,10 @@ fn aiur_fn_26(
         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_30] = { let __args: [G; IN_30] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_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 __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_26] = [__v_12];
-            record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_19] = [__v_12];
+            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -3596,10 +3227,10 @@ fn aiur_fn_26(
             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_26] = { let __args: [G; IN_26] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; 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_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 __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_26] = [__v_16];
-            record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_19] = [__v_16];
+            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -3611,15 +3242,15 @@ fn aiur_fn_26(
   })
 }
 
-const INPUT_SIZE_27: usize = 1;
-const IN_27: usize = 1;
-const OUT_27: usize = 64;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_20: usize = 1;
+const IN_20: usize = 1;
+const OUT_20: usize = 64;
+fn aiur_fn_20(
+  inp: [G; IN_20],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], ExecError> {
+) -> Result<[G; OUT_20], 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 };
@@ -4006,8 +3637,8 @@ fn aiur_fn_27(
                                                                                                                                                                                                                                                                 let __v_192: G = __loaded[2];
                                                                                                                                                                                                                                                                 match __v_190.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_27] = [__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[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                    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));
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -4332,22 +3963,22 @@ fn aiur_fn_27(
   })
 }
 
-const INPUT_SIZE_28: usize = 2;
-const IN_28: usize = 2;
-const OUT_28: usize = 1;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_21: usize = 2;
+const IN_21: usize = 2;
+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_28], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_28] = [__v_0];
-        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_21] = [__v_0];
+        record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -4356,25 +3987,25 @@ fn aiur_fn_28(
         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_28] = { let __args: [G; IN_28] = [__v_4, __v_6]; 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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_28] = [__v_7];
-        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_21] = [__v_7];
+        record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_29: usize = 6;
-const IN_29: usize = 6;
-const OUT_29: usize = 1;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+const INPUT_SIZE_22: usize = 6;
+const IN_22: usize = 6;
+const OUT_22: usize = 1;
+fn aiur_fn_22(
+  inp: [G; IN_22],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], ExecError> {
+) -> Result<[G; OUT_22], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -4524,7 +4155,7 @@ fn aiur_fn_29(
                                             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_33] = { let __args: [G; IN_33] = [__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[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_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 __v_125: G = __r_arr[0];
                                             let __v_126: G = __r_arr[1];
                                             let __v_127: G = __r_arr[2];
@@ -4558,62 +4189,62 @@ fn aiur_fn_29(
                                             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_29] = [__v_157];
-                                            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_22] = [__v_157];
+                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __ret: [G; OUT_29] = [__v_5];
-                                            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_22] = [__v_5];
+                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_29] = [__v_5];
-                                        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_22] = [__v_5];
+                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_29] = [__v_5];
-                                    record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_22] = [__v_5];
+                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_29] = [__v_5];
-                                record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_22] = [__v_5];
+                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_29] = [__v_5];
-                            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_22] = [__v_5];
+                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_29] = [__v_5];
-                        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_22] = [__v_5];
+                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_29] = [__v_5];
-                    record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_22] = [__v_5];
+                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_29] = [__v_5];
-                record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_22] = [__v_5];
+                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -4654,8 +4285,8 @@ fn aiur_fn_29(
             let __v_40: G = __loaded[30];
             let __v_41: G = __loaded[31];
             let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_29] = [__v_42];
-            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_22] = [__v_42];
+            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -4680,9 +4311,9 @@ fn aiur_fn_29(
         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_28] = { let __args: [G; IN_28] = [__v_0, __v_25]; 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_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 __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_26]; 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_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 __v_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -4790,7 +4421,7 @@ fn aiur_fn_29(
         let __v_129: G = __loaded[5];
         let __v_130: G = __loaded[6];
         let __v_131: G = __loaded[7];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_132: G = __r_arr[0];
         let __v_133: G = __r_arr[1];
         let __v_134: G = __r_arr[2];
@@ -4824,23 +4455,23 @@ fn aiur_fn_29(
         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_29] = [__v_164];
-        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_22] = [__v_164];
+        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_30: usize = 6;
-const IN_30: usize = 6;
-const OUT_30: usize = 1;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+const INPUT_SIZE_23: usize = 6;
+const IN_23: usize = 6;
+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_30], 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];
@@ -4851,7 +4482,7 @@ fn aiur_fn_30(
     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_27] = { let __args: [G; IN_27] = [__v_1]; 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_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 __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
@@ -4918,7 +4549,7 @@ fn aiur_fn_30(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0]; 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_762] = { let __args: [G; IN_762] = [__v_0]; 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 __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];
@@ -5010,7 +4641,7 @@ fn aiur_fn_30(
         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_33] = { let __args: [G; IN_33] = [__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[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_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 __v_160: G = __r_arr[0];
         let __v_161: G = __r_arr[1];
         let __v_162: G = __r_arr[2];
@@ -5058,7 +4689,7 @@ fn aiur_fn_30(
         let __v_203: G = __loaded[5];
         let __v_204: G = __loaded[6];
         let __v_205: G = __loaded[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_206: G = __r_arr[0];
         let __v_207: G = __r_arr[1];
         let __v_208: G = __r_arr[2];
@@ -5069,17 +4700,17 @@ fn aiur_fn_30(
         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_26] = { let __args: [G; IN_26] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; 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_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 __v_216: G = __r_arr[0];
-        let __ret: [G; OUT_30] = [__v_216];
-        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_23] = [__v_216];
+        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0]; 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_762] = { let __args: [G; IN_762] = [__v_0]; 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 __v_73: G = __r_arr[0];
         let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0]; 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_762] = { let __args: [G; IN_762] = [__v_0]; 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 __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];
@@ -5143,7 +4774,7 @@ fn aiur_fn_30(
         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_33] = { let __args: [G; IN_33] = [__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[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_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 __v_134: G = __r_arr[0];
         let __v_135: G = __r_arr[1];
         let __v_136: G = __r_arr[2];
@@ -5183,25 +4814,25 @@ fn aiur_fn_30(
         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_26] = { let __args: [G; IN_26] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; 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_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 __v_173: G = __r_arr[0];
-        let __ret: [G; OUT_30] = [__v_173];
-        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_23] = [__v_173];
+        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_31: usize = 24;
-const IN_31: usize = 24;
-const OUT_31: usize = 16;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+const INPUT_SIZE_24: usize = 24;
+const IN_24: usize = 24;
+const OUT_24: usize = 16;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_31], 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];
@@ -5401,21 +5032,21 @@ fn aiur_fn_31(
     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_31] = [__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[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_32: usize = 128;
-const IN_32: usize = 128;
-const OUT_32: usize = 128;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+const INPUT_SIZE_25: usize = 128;
+const IN_25: usize = 128;
+const OUT_25: usize = 128;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_32], 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];
@@ -5545,7 +5176,7 @@ fn aiur_fn_32(
     let __v_125: G = inp[125];
     let __v_126: G = inp[126];
     let __v_127: G = inp[127];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[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_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 __v_128: G = __r_arr[0];
     let __v_129: G = __r_arr[1];
     let __v_130: G = __r_arr[2];
@@ -5562,7 +5193,7 @@ fn aiur_fn_32(
     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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_144: G = __r_arr[0];
     let __v_145: G = __r_arr[1];
     let __v_146: G = __r_arr[2];
@@ -5579,7 +5210,7 @@ fn aiur_fn_32(
     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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_160: G = __r_arr[0];
     let __v_161: G = __r_arr[1];
     let __v_162: G = __r_arr[2];
@@ -5596,7 +5227,7 @@ fn aiur_fn_32(
     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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_176: G = __r_arr[0];
     let __v_177: G = __r_arr[1];
     let __v_178: G = __r_arr[2];
@@ -5613,7 +5244,7 @@ fn aiur_fn_32(
     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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_192: G = __r_arr[0];
     let __v_193: G = __r_arr[1];
     let __v_194: G = __r_arr[2];
@@ -5630,7 +5261,7 @@ fn aiur_fn_32(
     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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_208: G = __r_arr[0];
     let __v_209: G = __r_arr[1];
     let __v_210: G = __r_arr[2];
@@ -5647,7 +5278,7 @@ fn aiur_fn_32(
     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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_224: G = __r_arr[0];
     let __v_225: G = __r_arr[1];
     let __v_226: G = __r_arr[2];
@@ -5664,7 +5295,7 @@ fn aiur_fn_32(
     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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_240: G = __r_arr[0];
     let __v_241: G = __r_arr[1];
     let __v_242: G = __r_arr[2];
@@ -5681,21 +5312,21 @@ fn aiur_fn_32(
     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_32] = [__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[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_33: usize = 106;
-const IN_33: usize = 106;
-const OUT_33: usize = 32;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+const INPUT_SIZE_26: usize = 106;
+const IN_26: usize = 106;
+const OUT_26: usize = 32;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_33], 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];
@@ -5825,7 +5456,7 @@ fn aiur_fn_33(
     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_32] = { let __args: [G; IN_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, __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[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_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 __v_128: G = __r_arr[0];
     let __v_129: G = __r_arr[1];
     let __v_130: G = __r_arr[2];
@@ -5954,7 +5585,7 @@ fn aiur_fn_33(
     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_32] = { let __args: [G; IN_32] = [__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[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_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 __v_256: G = __r_arr[0];
     let __v_257: G = __r_arr[1];
     let __v_258: G = __r_arr[2];
@@ -6083,7 +5714,7 @@ fn aiur_fn_33(
     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_32] = { let __args: [G; IN_32] = [__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[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_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 __v_384: G = __r_arr[0];
     let __v_385: G = __r_arr[1];
     let __v_386: G = __r_arr[2];
@@ -6212,7 +5843,7 @@ fn aiur_fn_33(
     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_32] = { let __args: [G; IN_32] = [__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[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_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 __v_512: G = __r_arr[0];
     let __v_513: G = __r_arr[1];
     let __v_514: G = __r_arr[2];
@@ -6341,7 +5972,7 @@ fn aiur_fn_33(
     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_32] = { let __args: [G; IN_32] = [__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[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_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 __v_640: G = __r_arr[0];
     let __v_641: G = __r_arr[1];
     let __v_642: G = __r_arr[2];
@@ -6470,7 +6101,7 @@ fn aiur_fn_33(
     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_32] = { let __args: [G; IN_32] = [__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[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_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 __v_768: G = __r_arr[0];
     let __v_769: G = __r_arr[1];
     let __v_770: G = __r_arr[2];
@@ -6599,7 +6230,7 @@ fn aiur_fn_33(
     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_32] = { let __args: [G; IN_32] = [__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[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_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 __v_896: G = __r_arr[0];
     let __v_897: G = __r_arr[1];
     let __v_898: G = __r_arr[2];
@@ -6760,322 +6391,21 @@ fn aiur_fn_33(
     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_33] = [__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[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_34: usize = 0;
-const IN_34: usize = 0;
-const OUT_34: usize = 22;
-fn aiur_fn_34(
-  inp: [G; IN_34],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_34], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(5);
-    let __v_1: G = G::from_u64(42);
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = G::from_u64(1);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__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[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_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 = G::from_u64(5);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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 __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(10);
-    let __v_13: G = G::from_u64(100);
-    let __v_14: G = G::from_u64(1);
-    let __v_15: G = G::from_u64(1);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; 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_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 = G::from_u64(20);
-    let __v_23: G = G::from_u64(200);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; 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_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 = __r_arr[4];
-    let __v_29: G = __r_arr[5];
-    let __v_30: G = G::from_u64(5);
-    let __v_31: G = G::from_u64(50);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_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 = G::from_u64(5);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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 __v_39: G = __r_arr[0];
-    let __v_40: G = G::from_u64(10);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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 __v_41: G = __r_arr[0];
-    let __v_42: G = G::from_u64(20);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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 __v_43: G = __r_arr[0];
-    let __v_44: G = G::from_u64(10);
-    let __v_45: G = G::from_u64(100);
-    let __v_46: G = G::from_u64(1);
-    let __v_47: G = G::from_u64(1);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; 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_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 = G::from_u64(10);
-    let __v_55: G = G::from_u64(999);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_54, __v_55, __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 __v_56: G = __r_arr[0];
-    let __v_57: G = __r_arr[1];
-    let __v_58: G = __r_arr[2];
-    let __v_59: G = __r_arr[3];
-    let __v_60: G = __r_arr[4];
-    let __v_61: G = __r_arr[5];
-    let __v_62: G = G::from_u64(10);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; 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 __v_63: G = __r_arr[0];
-    let __v_64: G = G::from_u64(1);
-    let __v_65: G = G::from_u64(10);
-    let __v_66: G = G::from_u64(1);
-    let __v_67: G = G::from_u64(1);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; 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_68: G = __r_arr[0];
-    let __v_69: G = __r_arr[1];
-    let __v_70: G = __r_arr[2];
-    let __v_71: G = __r_arr[3];
-    let __v_72: G = __r_arr[4];
-    let __v_73: G = __r_arr[5];
-    let __v_74: G = G::from_u64(2);
-    let __v_75: G = G::from_u64(20);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; 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_76: G = __r_arr[0];
-    let __v_77: G = __r_arr[1];
-    let __v_78: G = __r_arr[2];
-    let __v_79: G = __r_arr[3];
-    let __v_80: G = __r_arr[4];
-    let __v_81: G = __r_arr[5];
-    let __v_82: G = G::from_u64(3);
-    let __v_83: G = G::from_u64(30);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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_84: G = __r_arr[0];
-    let __v_85: G = __r_arr[1];
-    let __v_86: G = __r_arr[2];
-    let __v_87: G = __r_arr[3];
-    let __v_88: G = __r_arr[4];
-    let __v_89: G = __r_arr[5];
-    let __v_90: G = G::from_u64(4);
-    let __v_91: G = G::from_u64(40);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; 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_92: G = __r_arr[0];
-    let __v_93: G = __r_arr[1];
-    let __v_94: G = __r_arr[2];
-    let __v_95: G = __r_arr[3];
-    let __v_96: G = __r_arr[4];
-    let __v_97: G = __r_arr[5];
-    let __v_98: G = G::from_u64(5);
-    let __v_99: G = G::from_u64(50);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; 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_100: G = __r_arr[0];
-    let __v_101: G = __r_arr[1];
-    let __v_102: G = __r_arr[2];
-    let __v_103: G = __r_arr[3];
-    let __v_104: G = __r_arr[4];
-    let __v_105: G = __r_arr[5];
-    let __v_106: G = G::from_u64(1);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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 __v_107: G = __r_arr[0];
-    let __v_108: G = G::from_u64(2);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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 __v_109: G = __r_arr[0];
-    let __v_110: G = G::from_u64(3);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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 __v_111: G = __r_arr[0];
-    let __v_112: G = G::from_u64(4);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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 __v_113: G = __r_arr[0];
-    let __v_114: G = G::from_u64(5);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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 __v_115: G = __r_arr[0];
-    let __v_116: G = G::from_u64(5);
-    let __v_117: G = G::from_u64(50);
-    let __v_118: G = G::from_u64(1);
-    let __v_119: G = G::from_u64(1);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; 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_120: G = __r_arr[0];
-    let __v_121: G = __r_arr[1];
-    let __v_122: G = __r_arr[2];
-    let __v_123: G = __r_arr[3];
-    let __v_124: G = __r_arr[4];
-    let __v_125: G = __r_arr[5];
-    let __v_126: G = G::from_u64(4);
-    let __v_127: G = G::from_u64(40);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; 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_128: G = __r_arr[0];
-    let __v_129: G = __r_arr[1];
-    let __v_130: G = __r_arr[2];
-    let __v_131: G = __r_arr[3];
-    let __v_132: G = __r_arr[4];
-    let __v_133: G = __r_arr[5];
-    let __v_134: G = G::from_u64(3);
-    let __v_135: G = G::from_u64(30);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; 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_136: G = __r_arr[0];
-    let __v_137: G = __r_arr[1];
-    let __v_138: G = __r_arr[2];
-    let __v_139: G = __r_arr[3];
-    let __v_140: G = __r_arr[4];
-    let __v_141: G = __r_arr[5];
-    let __v_142: G = G::from_u64(2);
-    let __v_143: G = G::from_u64(20);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; 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_144: G = __r_arr[0];
-    let __v_145: G = __r_arr[1];
-    let __v_146: G = __r_arr[2];
-    let __v_147: G = __r_arr[3];
-    let __v_148: G = __r_arr[4];
-    let __v_149: G = __r_arr[5];
-    let __v_150: G = G::from_u64(1);
-    let __v_151: G = G::from_u64(10);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; 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_152: G = __r_arr[0];
-    let __v_153: G = __r_arr[1];
-    let __v_154: G = __r_arr[2];
-    let __v_155: G = __r_arr[3];
-    let __v_156: G = __r_arr[4];
-    let __v_157: G = __r_arr[5];
-    let __v_158: G = G::from_u64(1);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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 __v_159: G = __r_arr[0];
-    let __v_160: G = G::from_u64(2);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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 __v_161: G = __r_arr[0];
-    let __v_162: G = G::from_u64(3);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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 __v_163: G = __r_arr[0];
-    let __v_164: G = G::from_u64(4);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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 __v_165: G = __r_arr[0];
-    let __v_166: G = G::from_u64(5);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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 __v_167: G = __r_arr[0];
-    let __v_168: G = G::from_u64(50);
-    let __v_169: G = G::from_u64(500);
-    let __v_170: G = G::from_u64(1);
-    let __v_171: G = G::from_u64(1);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; 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_172: G = __r_arr[0];
-    let __v_173: G = __r_arr[1];
-    let __v_174: G = __r_arr[2];
-    let __v_175: G = __r_arr[3];
-    let __v_176: G = __r_arr[4];
-    let __v_177: G = __r_arr[5];
-    let __v_178: G = G::from_u64(30);
-    let __v_179: G = G::from_u64(300);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; 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_180: G = __r_arr[0];
-    let __v_181: G = __r_arr[1];
-    let __v_182: G = __r_arr[2];
-    let __v_183: G = __r_arr[3];
-    let __v_184: G = __r_arr[4];
-    let __v_185: G = __r_arr[5];
-    let __v_186: G = G::from_u64(70);
-    let __v_187: G = G::from_u64(700);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; 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_188: G = __r_arr[0];
-    let __v_189: G = __r_arr[1];
-    let __v_190: G = __r_arr[2];
-    let __v_191: G = __r_arr[3];
-    let __v_192: G = __r_arr[4];
-    let __v_193: G = __r_arr[5];
-    let __v_194: G = G::from_u64(20);
-    let __v_195: G = G::from_u64(200);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; 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_196: G = __r_arr[0];
-    let __v_197: G = __r_arr[1];
-    let __v_198: G = __r_arr[2];
-    let __v_199: G = __r_arr[3];
-    let __v_200: G = __r_arr[4];
-    let __v_201: G = __r_arr[5];
-    let __v_202: G = G::from_u64(40);
-    let __v_203: G = G::from_u64(400);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; 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_204: G = __r_arr[0];
-    let __v_205: G = __r_arr[1];
-    let __v_206: G = __r_arr[2];
-    let __v_207: G = __r_arr[3];
-    let __v_208: G = __r_arr[4];
-    let __v_209: G = __r_arr[5];
-    let __v_210: G = G::from_u64(60);
-    let __v_211: G = G::from_u64(600);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; 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_212: G = __r_arr[0];
-    let __v_213: G = __r_arr[1];
-    let __v_214: G = __r_arr[2];
-    let __v_215: G = __r_arr[3];
-    let __v_216: G = __r_arr[4];
-    let __v_217: G = __r_arr[5];
-    let __v_218: G = G::from_u64(80);
-    let __v_219: G = G::from_u64(800);
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; 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_220: G = __r_arr[0];
-    let __v_221: G = __r_arr[1];
-    let __v_222: G = __r_arr[2];
-    let __v_223: G = __r_arr[3];
-    let __v_224: G = __r_arr[4];
-    let __v_225: G = __r_arr[5];
-    let __v_226: G = G::from_u64(20);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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 __v_227: G = __r_arr[0];
-    let __v_228: G = G::from_u64(30);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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 __v_229: G = __r_arr[0];
-    let __v_230: G = G::from_u64(40);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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 __v_231: G = __r_arr[0];
-    let __v_232: G = G::from_u64(50);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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 __v_233: G = __r_arr[0];
-    let __v_234: G = G::from_u64(60);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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 __v_235: G = __r_arr[0];
-    let __v_236: G = G::from_u64(70);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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 __v_237: G = __r_arr[0];
-    let __v_238: G = G::from_u64(80);
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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 __v_239: G = __r_arr[0];
-    let __ret: [G; OUT_34] = [__v_11, __v_39, __v_41, __v_43, __v_63, __v_107, __v_109, __v_111, __v_113, __v_115, __v_159, __v_161, __v_163, __v_165, __v_167, __v_227, __v_229, __v_231, __v_233, __v_235, __v_237, __v_239];
-    record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_35: usize = 19;
-const IN_35: usize = 19;
-const OUT_35: usize = 1;
-fn aiur_fn_35(
-  inp: [G; IN_35],
+const INPUT_SIZE_27: usize = 19;
+const IN_27: usize = 19;
+const OUT_27: usize = 1;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_35], 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];
@@ -7099,22 +6429,22 @@ fn aiur_fn_35(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_20];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_20];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_19: G = G::from_u64(1);
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_20];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_20];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_9]; 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_744] = { let __args: [G; IN_744] = [__v_9]; 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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7124,18 +6454,18 @@ fn aiur_fn_35(
         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_40] = { let __args: [G; IN_40] = [__v_9, __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 __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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_30];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_30];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_9]; 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_744] = { let __args: [G; IN_744] = [__v_9]; 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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7145,14 +6475,14 @@ fn aiur_fn_35(
         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_40] = { let __args: [G; IN_40] = [__v_9, __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 __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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_30];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_30];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
@@ -7176,34 +6506,34 @@ fn aiur_fn_35(
         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_35] = { let __args: [G; IN_35] = [__v_19, __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[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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_40: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_40];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_40];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_19: G = G::from_u64(5);
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_20];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_20];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_19: G = G::from_u64(6);
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_20];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_20];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        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, __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_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7213,16 +6543,16 @@ fn aiur_fn_35(
         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_44] = { let __args: [G; IN_44] = [__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[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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_29];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_29];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        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, __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_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7232,16 +6562,16 @@ fn aiur_fn_35(
         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_45] = { let __args: [G; IN_45] = [__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[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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_29];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_29];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        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, __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 __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];
@@ -7251,12 +6581,12 @@ fn aiur_fn_35(
         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_46] = { let __args: [G; IN_46] = [__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[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_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_39] = { let __args: [G; IN_39] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_29];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_29];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
@@ -7318,24 +6648,24 @@ fn aiur_fn_35(
         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_35] = { let __args: [G; IN_35] = [__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[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_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 __v_74: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __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[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_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 __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_77: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_77];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_77];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
         let __v_19: G = G::from_u64(11);
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_35] = [__v_20];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_27] = [__v_20];
+        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7345,15 +6675,15 @@ fn aiur_fn_35(
   })
 }
 
-const INPUT_SIZE_36: usize = 10;
-const IN_36: usize = 10;
-const OUT_36: usize = 1;
-fn aiur_fn_36(
-  inp: [G; IN_36],
+const INPUT_SIZE_28: usize = 10;
+const IN_28: usize = 10;
+const OUT_28: usize = 1;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_36], 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];
@@ -7367,8 +6697,8 @@ fn aiur_fn_36(
     let __v_9: G = inp[9];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_36] = [__v_9];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_28] = [__v_9];
+        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7376,26 +6706,26 @@ fn aiur_fn_36(
         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_36] = { let __args: [G; IN_36] = [__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[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_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 __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_36] = [__v_15];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_28] = [__v_15];
+        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_37: usize = 9;
-const IN_37: usize = 9;
-const OUT_37: usize = 1;
-fn aiur_fn_37(
-  inp: [G; IN_37],
+const INPUT_SIZE_29: usize = 9;
+const IN_29: usize = 9;
+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_37], 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];
@@ -7416,8 +6746,8 @@ fn aiur_fn_37(
           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_37] = [__v_13];
-            record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_29] = [__v_13];
+            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7426,11 +6756,11 @@ fn aiur_fn_37(
             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_36] = { let __args: [G; IN_36] = [__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[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_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 __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_37] = [__v_18];
-            record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_29] = [__v_18];
+            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7441,26 +6771,26 @@ fn aiur_fn_37(
         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_36] = { let __args: [G; IN_36] = [__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[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_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 __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_37] = [__v_18];
-        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_18];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 10;
-const IN_38: usize = 10;
-const OUT_38: usize = 1;
-fn aiur_fn_38(
-  inp: [G; IN_38],
+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_38], 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];
@@ -7485,8 +6815,8 @@ fn aiur_fn_38(
             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_38] = [__v_17];
-            record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_30] = [__v_17];
+            record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7498,11 +6828,11 @@ fn aiur_fn_38(
             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_36] = { let __args: [G; IN_36] = [__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[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_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 __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_38] = [__v_22];
-            record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_30] = [__v_22];
+            record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7516,26 +6846,26 @@ fn aiur_fn_38(
         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_36] = { let __args: [G; IN_36] = [__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[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_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 __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_38] = [__v_22];
-        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_30] = [__v_22];
+        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_39: usize = 10;
-const IN_39: usize = 10;
-const OUT_39: usize = 1;
-fn aiur_fn_39(
-  inp: [G; IN_39],
+const INPUT_SIZE_31: usize = 10;
+const IN_31: usize = 10;
+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_39], 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];
@@ -7560,8 +6890,8 @@ fn aiur_fn_39(
             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_39] = [__v_17];
-            record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_31] = [__v_17];
+            record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7573,11 +6903,11 @@ fn aiur_fn_39(
             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_36] = { let __args: [G; IN_36] = [__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[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_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 __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_39] = [__v_22];
-            record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_31] = [__v_22];
+            record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7591,26 +6921,26 @@ fn aiur_fn_39(
         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_36] = { let __args: [G; IN_36] = [__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[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_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 __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_39] = [__v_22];
-        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_31] = [__v_22];
+        record.function_queries[31].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_32: usize = 2;
+const IN_32: usize = 2;
+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_40], 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];
@@ -7627,17 +6957,17 @@ fn aiur_fn_40(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_40] = [__v_1];
-        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_32] = [__v_1];
+        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_11, __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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_40] = [__v_13];
-        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_32] = [__v_13];
+        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7647,15 +6977,15 @@ fn aiur_fn_40(
   })
 }
 
-const INPUT_SIZE_41: usize = 18;
-const IN_41: usize = 18;
-const OUT_41: usize = 8;
-fn aiur_fn_41(
-  inp: [G; IN_41],
+const INPUT_SIZE_33: usize = 18;
+const IN_33: usize = 18;
+const OUT_33: usize = 8;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_41], 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];
@@ -7696,7 +7026,7 @@ fn aiur_fn_41(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __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[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_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 __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7705,7 +7035,7 @@ fn aiur_fn_41(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7714,8 +7044,8 @@ fn aiur_fn_41(
         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_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -7727,23 +7057,23 @@ fn aiur_fn_41(
         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_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_42: usize = 18;
-const IN_42: usize = 18;
-const OUT_42: usize = 8;
-fn aiur_fn_42(
-  inp: [G; IN_42],
+const INPUT_SIZE_34: usize = 18;
+const IN_34: usize = 18;
+const OUT_34: usize = 8;
+fn aiur_fn_34(
+  inp: [G; IN_34],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_42], 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];
@@ -7784,7 +7114,7 @@ fn aiur_fn_42(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __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[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_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 __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7793,7 +7123,7 @@ fn aiur_fn_42(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7802,8 +7132,8 @@ fn aiur_fn_42(
         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_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -7815,23 +7145,23 @@ fn aiur_fn_42(
         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_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_43: usize = 18;
-const IN_43: usize = 18;
-const OUT_43: usize = 8;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+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_43], 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];
@@ -7872,7 +7202,7 @@ fn aiur_fn_43(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        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_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[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_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];
@@ -7881,7 +7211,7 @@ fn aiur_fn_43(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7890,8 +7220,8 @@ fn aiur_fn_43(
         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_43] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[43].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);
       },
       _ => {
@@ -7903,23 +7233,23 @@ fn aiur_fn_43(
         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_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[43].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_44: usize = 19;
-const IN_44: usize = 19;
-const OUT_44: usize = 1;
-fn aiur_fn_44(
-  inp: [G; IN_44],
+const INPUT_SIZE_36: usize = 19;
+const IN_36: usize = 19;
+const OUT_36: usize = 1;
+fn aiur_fn_36(
+  inp: [G; IN_36],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_44], 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];
@@ -7980,34 +7310,34 @@ fn aiur_fn_44(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_19, __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[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_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 __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_44] = [__v_56];
-        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_36] = [__v_56];
+        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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, __v_18]; 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_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 __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_44] = [__v_19];
-        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_36] = [__v_19];
+        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_45: usize = 19;
-const IN_45: usize = 19;
-const OUT_45: usize = 1;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_37: usize = 19;
+const IN_37: usize = 19;
+const OUT_37: usize = 1;
+fn aiur_fn_37(
+  inp: [G; IN_37],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_45], 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];
@@ -8068,34 +7398,34 @@ fn aiur_fn_45(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__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[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_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __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[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_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 __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_45] = [__v_56];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_37] = [__v_56];
+        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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, __v_18]; 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_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 __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_45] = [__v_19];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_37] = [__v_19];
+        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_46: usize = 19;
-const IN_46: usize = 19;
-const OUT_46: usize = 1;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+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_46], 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];
@@ -8156,34 +7486,34 @@ fn aiur_fn_46(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__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[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_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __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[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_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 __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_46] = [__v_56];
-        record.function_queries[46].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_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, __v_18]; 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_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 __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_46] = [__v_19];
-        record.function_queries[46].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_47: usize = 2;
-const IN_47: usize = 2;
-const OUT_47: usize = 1;
-fn aiur_fn_47(
-  inp: [G; IN_47],
+const INPUT_SIZE_39: usize = 2;
+const IN_39: usize = 2;
+const OUT_39: usize = 1;
+fn aiur_fn_39(
+  inp: [G; IN_39],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_47], 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];
@@ -8284,21 +7614,21 @@ fn aiur_fn_47(
     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_47] = [__v_97];
-    record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_39] = [__v_97];
+    record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_48: usize = 2;
-const IN_48: usize = 2;
-const OUT_48: usize = 1;
-fn aiur_fn_48(
-  inp: [G; IN_48],
+const INPUT_SIZE_40: usize = 2;
+const IN_40: usize = 2;
+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_48], 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];
@@ -8307,20 +7637,20 @@ fn aiur_fn_48(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(2);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8332,20 +7662,20 @@ fn aiur_fn_48(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(4);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(5);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(6);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8357,20 +7687,20 @@ fn aiur_fn_48(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(8);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(9);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(10);
-            let __ret: [G; OUT_48] = [__v_2];
-            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_40] = [__v_2];
+            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8385,15 +7715,15 @@ fn aiur_fn_48(
   })
 }
 
-const INPUT_SIZE_49: usize = 9;
-const IN_49: usize = 9;
-const OUT_49: usize = 8;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+const INPUT_SIZE_41: usize = 9;
+const IN_41: usize = 9;
+const OUT_41: usize = 8;
+fn aiur_fn_41(
+  inp: [G; IN_41],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_49], 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];
@@ -8416,7 +7746,7 @@ fn aiur_fn_49(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__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[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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8425,7 +7755,7 @@ fn aiur_fn_49(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -8434,8 +7764,8 @@ fn aiur_fn_49(
         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_49] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -8447,23 +7777,23 @@ fn aiur_fn_49(
         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_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_50: usize = 9;
-const IN_50: usize = 9;
-const OUT_50: usize = 9;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_42: usize = 9;
+const IN_42: usize = 9;
+const OUT_42: usize = 9;
+fn aiur_fn_42(
+  inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_50], 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];
@@ -8486,7 +7816,7 @@ fn aiur_fn_50(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8496,28 +7826,28 @@ fn aiur_fn_50(
         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_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_51: usize = 10;
-const IN_51: usize = 10;
-const OUT_51: usize = 1;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_43: usize = 10;
+const IN_43: usize = 10;
+const OUT_43: usize = 1;
+fn aiur_fn_43(
+  inp: [G; IN_43],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_51], 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];
@@ -8534,12 +7864,12 @@ fn aiur_fn_51(
         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_51] = [__v_12];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_12];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__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[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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -8548,7 +7878,7 @@ fn aiur_fn_51(
         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_50] = { let __args: [G; IN_50] = [__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[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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8559,12 +7889,12 @@ fn aiur_fn_51(
         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_51] = { let __args: [G; IN_51] = [__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[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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_51] = [__v_29];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_29];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -8597,14 +7927,14 @@ fn aiur_fn_51(
         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_51] = { let __args: [G; IN_51] = [__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[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_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 __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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[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_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 __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_51] = [__v_39];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_39];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
@@ -8637,22 +7967,22 @@ fn aiur_fn_51(
         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_51] = { let __args: [G; IN_51] = [__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[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_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 __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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[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_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 __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_51] = [__v_39];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_39];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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[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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_51] = [__v_11];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_11];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8662,15 +7992,15 @@ fn aiur_fn_51(
   })
 }
 
-const INPUT_SIZE_52: usize = 2;
-const IN_52: usize = 2;
-const OUT_52: usize = 1;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_44: usize = 2;
+const IN_44: usize = 2;
+const OUT_44: usize = 1;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_52], 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];
@@ -8680,8 +8010,8 @@ fn aiur_fn_52(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_52] = [__v_1];
-        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_44] = [__v_1];
+        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8704,12 +8034,12 @@ fn aiur_fn_52(
         let __v_20: G = __loaded[15];
         let __v_21: G = __loaded[16];
         let __v_22: G = __loaded[17];
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __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 __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 __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_5, __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[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_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 __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_52] = [__v_24];
-        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_44] = [__v_24];
+        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8719,15 +8049,15 @@ fn aiur_fn_52(
   })
 }
 
-const INPUT_SIZE_53: usize = 2;
-const IN_53: usize = 2;
-const OUT_53: usize = 1;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+const INPUT_SIZE_45: usize = 2;
+const IN_45: usize = 2;
+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_53], 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];
@@ -8737,8 +8067,8 @@ fn aiur_fn_53(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_53] = [__v_1];
-        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_1];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8752,12 +8082,12 @@ fn aiur_fn_53(
         let __v_11: G = __loaded[6];
         let __v_12: G = __loaded[7];
         let __v_13: G = __loaded[8];
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; 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_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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[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_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 __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_53] = [__v_15];
-        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_15];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8767,15 +8097,15 @@ fn aiur_fn_53(
   })
 }
 
-const INPUT_SIZE_54: usize = 2;
-const IN_54: usize = 2;
-const OUT_54: usize = 1;
-fn aiur_fn_54(
-  inp: [G; IN_54],
+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_54], 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];
@@ -8785,17 +8115,17 @@ fn aiur_fn_54(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_54] = [__v_1];
-        record.function_queries[54].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 => {
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; 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_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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; 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_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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_54] = [__v_6];
-        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_46] = [__v_6];
+        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8805,15 +8135,15 @@ fn aiur_fn_54(
   })
 }
 
-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_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_55], 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];
@@ -8822,32 +8152,32 @@ fn aiur_fn_55(
         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_55] = [__v_4];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_47] = [__v_4];
+        record.function_queries[47].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_55] = [__v_4];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_47] = [__v_4];
+        record.function_queries[47].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_55] = [__v_4];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_47] = [__v_4];
+        record.function_queries[47].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_55] = [__v_4];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_47] = [__v_4];
+        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8857,15 +8187,15 @@ fn aiur_fn_55(
   })
 }
 
-const INPUT_SIZE_56: usize = 13;
-const IN_56: usize = 13;
-const OUT_56: usize = 1;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_48: usize = 13;
+const IN_48: usize = 13;
+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_56], 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];
@@ -8920,33 +8250,33 @@ fn aiur_fn_56(
         let __v_46: G = __loaded[15];
         let __v_47: G = __loaded[16];
         let __v_48: G = __loaded[17];
-        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 __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 __v_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(0);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_51: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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[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_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 __v_52: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __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_56] = [__v_54];
-        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_48] = [__v_54];
+        record.function_queries[48].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_49: usize = 10;
+const IN_49: usize = 10;
+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_57], 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];
@@ -8979,27 +8309,27 @@ fn aiur_fn_57(
         let __v_25: G = __loaded[15];
         let __v_26: G = __loaded[16];
         let __v_27: G = __loaded[17];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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[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_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 __v_28: G = __r_arr[0];
-        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_28]; 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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_57] = [__v_29];
-        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_49] = [__v_29];
+        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_58: usize = 2;
-const IN_58: usize = 2;
-const OUT_58: usize = 1;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_50: usize = 2;
+const IN_50: usize = 2;
+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_58], 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];
@@ -9017,17 +8347,17 @@ fn aiur_fn_58(
     let __v_12: G = __loaded[10];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_58] = [__v_1];
-        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_1];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_1]; 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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__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[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_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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_58] = [__v_14];
-        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_14];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9037,15 +8367,15 @@ fn aiur_fn_58(
   })
 }
 
-const INPUT_SIZE_59: usize = 45;
-const IN_59: usize = 45;
-const OUT_59: usize = 1;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+const INPUT_SIZE_51: usize = 45;
+const IN_51: usize = 45;
+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_59], 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];
@@ -9116,7 +8446,7 @@ fn aiur_fn_59(
         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_789] = { let __args: [G; IN_789] = [__v_43]; 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_759] = { let __args: [G; IN_759] = [__v_43]; 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_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -9126,40 +8456,40 @@ fn aiur_fn_59(
         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_58] = { let __args: [G; IN_58] = [__v_43, __v_44]; 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_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 __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_77: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_79: G = __r_arr[0];
-        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_79]; 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_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 __v_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_81: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __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_59] = [__v_83];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_83];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_60: usize = 11;
-const IN_60: usize = 11;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_52: usize = 11;
+const IN_52: usize = 11;
+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_60], 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];
@@ -9194,28 +8524,28 @@ fn aiur_fn_60(
         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_35] = { let __args: [G; IN_35] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[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_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 __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __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_60] = [__v_32];
-        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_52] = [__v_32];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_61: usize = 11;
-const IN_61: usize = 11;
-const OUT_61: usize = 1;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_53: usize = 11;
+const IN_53: usize = 11;
+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_61], 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];
@@ -9249,29 +8579,29 @@ fn aiur_fn_61(
         let __v_26: G = __loaded[15];
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[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_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 __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0, __v_30]; 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_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 __v_31: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_31];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_53] = [__v_31];
+        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_62: usize = 35;
-const IN_62: usize = 35;
-const OUT_62: usize = 1;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_54: usize = 35;
+const IN_54: usize = 35;
+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_62], 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];
@@ -9330,34 +8660,34 @@ fn aiur_fn_62(
         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_35] = { let __args: [G; IN_35] = [__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[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_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 __v_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __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_62] = [__v_59];
-        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_59];
+        record.function_queries[54].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_55: usize = 2;
+const IN_55: usize = 2;
+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_63], 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];
@@ -9400,17 +8730,17 @@ fn aiur_fn_63(
     let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_63] = [__v_1];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_1];
+        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_37, __v_1]; 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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__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[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_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 __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_63] = [__v_39];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_39];
+        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9420,15 +8750,15 @@ fn aiur_fn_63(
   })
 }
 
-const INPUT_SIZE_64: usize = 28;
-const IN_64: usize = 28;
-const OUT_64: usize = 1;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_56: usize = 28;
+const IN_56: usize = 28;
+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_64], 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];
@@ -9479,7 +8809,7 @@ fn aiur_fn_64(
         let __v_43: G = __loaded[15];
         let __v_44: G = __loaded[16];
         let __v_45: G = __loaded[17];
-        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_26]; 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_750] = { let __args: [G; IN_750] = [__v_26]; 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 __v_46: G = __r_arr[0];
         let __v_47: G = __r_arr[1];
         let __v_48: G = __r_arr[2];
@@ -9489,36 +8819,36 @@ fn aiur_fn_64(
         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_63] = { let __args: [G; IN_63] = [__v_26, __v_27]; 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_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_59: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __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_64] = [__v_61];
-        record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_56] = [__v_61];
+        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_65: usize = 10;
-const IN_65: usize = 10;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_57: usize = 10;
+const IN_57: usize = 10;
+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_65], 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];
@@ -9532,27 +8862,27 @@ fn aiur_fn_65(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_8, __v_9]; 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_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 __v_10: G = __r_arr[0];
-        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_10]; 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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_11];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_57] = [__v_11];
+        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_66: usize = 18;
-const IN_66: usize = 18;
-const OUT_66: usize = 1;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_58: usize = 18;
+const IN_58: usize = 18;
+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_66], 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];
@@ -9574,29 +8904,29 @@ fn aiur_fn_66(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_16, __v_17]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_19: G = __r_arr[0];
-        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_19]; 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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_66] = [__v_20];
-        record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_58] = [__v_20];
+        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_67: usize = 46;
-const IN_67: usize = 46;
-const OUT_67: usize = 1;
-fn aiur_fn_67(
-  inp: [G; IN_67],
+const INPUT_SIZE_59: usize = 46;
+const IN_59: usize = 46;
+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_67], 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];
@@ -9648,31 +8978,31 @@ fn aiur_fn_67(
       0u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        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_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_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 __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_67] = [__v_49];
-        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_59] = [__v_49];
+        record.function_queries[59].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_64] = { let __args: [G; IN_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, __v_14, __v_15, __v_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[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_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 __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_67] = [__v_49];
-        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_59] = [__v_49];
+        record.function_queries[59].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_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_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[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_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 __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_67] = [__v_49];
-        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_59] = [__v_49];
+        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9682,15 +9012,15 @@ fn aiur_fn_67(
   })
 }
 
-const INPUT_SIZE_68: usize = 2;
-const IN_68: usize = 2;
-const OUT_68: usize = 1;
-fn aiur_fn_68(
-  inp: [G; IN_68],
+const INPUT_SIZE_60: usize = 2;
+const IN_60: usize = 2;
+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_68], 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];
@@ -9744,17 +9074,17 @@ fn aiur_fn_68(
     let __v_48: G = __loaded[46];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_68] = [__v_1];
-        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_60] = [__v_1];
+        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_48, __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 __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 __v_49: G = __r_arr[0];
-        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_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[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_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 __v_50: G = __r_arr[0];
-        let __ret: [G; OUT_68] = [__v_50];
-        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_60] = [__v_50];
+        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9764,15 +9094,15 @@ fn aiur_fn_68(
   })
 }
 
-const INPUT_SIZE_69: usize = 46;
-const IN_69: usize = 46;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_69],
+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_69], 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];
@@ -9822,59 +9152,59 @@ fn aiur_fn_69(
     let __v_45: G = inp[45];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        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_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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        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_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 __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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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[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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__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[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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__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[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 __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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__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[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 __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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__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[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 __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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_46];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9884,19 +9214,19 @@ fn aiur_fn_69(
   })
 }
 
-const INPUT_SIZE_70: usize = 2;
-const IN_70: usize = 2;
-const OUT_70: usize = 1;
-fn aiur_fn_70(
-  inp: [G; IN_70],
+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_70], 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];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; 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 __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0]; 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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9905,29 +9235,29 @@ fn aiur_fn_70(
     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_52] = { let __args: [G; IN_52] = [__v_0, __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 __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 __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_70] = [__v_11];
-    record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_62] = [__v_11];
+    record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_71: usize = 2;
-const IN_71: usize = 2;
-const OUT_71: usize = 1;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_63: usize = 2;
+const IN_63: usize = 2;
+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_71], 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];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; 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 __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0]; 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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9936,29 +9266,29 @@ fn aiur_fn_71(
     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_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; 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_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_37] = { let __args: [G; IN_37] = [__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[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_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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_71] = [__v_11];
-    record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_63] = [__v_11];
+    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_72: usize = 2;
-const IN_72: usize = 2;
-const OUT_72: usize = 1;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+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_72], 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_775] = { let __args: [G; IN_775] = [__v_0]; 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 __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0]; 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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9967,25 +9297,25 @@ fn aiur_fn_72(
     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_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; 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_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 __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[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_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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_72] = [__v_11];
-    record.function_queries[72].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_73: usize = 49;
-const IN_73: usize = 49;
-const OUT_73: usize = 1;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+const INPUT_SIZE_65: usize = 49;
+const IN_65: usize = 49;
+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_73], 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];
@@ -10038,15 +9368,15 @@ fn aiur_fn_73(
     let __v_48: G = inp[48];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_47, __v_48]; 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_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 __v_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46, __v_49]; 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_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 __v_50: G = __r_arr[0];
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_45, __v_50]; 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_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 __v_51: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__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 __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_1]; 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -10056,12 +9386,12 @@ fn aiur_fn_73(
             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_68] = { let __args: [G; IN_68] = [__v_1, __v_51]; 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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -10074,12 +9404,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -10092,12 +9422,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
@@ -10110,12 +9440,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
@@ -10128,12 +9458,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
@@ -10146,12 +9476,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
@@ -10164,12 +9494,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
@@ -10182,12 +9512,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
@@ -10200,12 +9530,12 @@ fn aiur_fn_73(
             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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_65] = [__v_62];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -10217,15 +9547,15 @@ fn aiur_fn_73(
   })
 }
 
-const INPUT_SIZE_74: usize = 1;
-const IN_74: usize = 1;
-const OUT_74: usize = 2;
-fn aiur_fn_74(
-  inp: [G; IN_74],
+const INPUT_SIZE_66: usize = 1;
+const IN_66: usize = 1;
+const OUT_66: usize = 2;
+fn aiur_fn_66(
+  inp: [G; IN_66],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_74], ExecError> {
+) -> Result<[G; OUT_66], 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 };
@@ -10234,8 +9564,8 @@ fn aiur_fn_74(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_74] = [__v_2, __v_3];
-        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_66] = [__v_2, __v_3];
+        record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -10243,8 +9573,8 @@ fn aiur_fn_74(
         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_74] = [__v_4, __v_7];
-        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_66] = [__v_4, __v_7];
+        record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10254,15 +9584,15 @@ fn aiur_fn_74(
   })
 }
 
-const INPUT_SIZE_75: usize = 2;
-const IN_75: usize = 2;
-const OUT_75: usize = 9;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_67: usize = 2;
+const IN_67: usize = 2;
+const OUT_67: usize = 9;
+fn aiur_fn_67(
+  inp: [G; IN_67],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_75], 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];
@@ -10276,8 +9606,8 @@ fn aiur_fn_75(
         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_75] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -10289,7 +9619,7 @@ fn aiur_fn_75(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_4, __v_6]; 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_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 __v_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             let __v_9: G = __r_arr[2];
@@ -10299,8 +9629,8 @@ fn aiur_fn_75(
             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_75] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
-            record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -10312,15 +9642,15 @@ fn aiur_fn_75(
   })
 }
 
-const INPUT_SIZE_76: usize = 1;
-const IN_76: usize = 1;
-const OUT_76: usize = 9;
-fn aiur_fn_76(
-  inp: [G; IN_76],
+const INPUT_SIZE_68: usize = 1;
+const IN_68: usize = 1;
+const OUT_68: usize = 9;
+fn aiur_fn_68(
+  inp: [G; IN_68],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_76], 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 };
@@ -10365,14 +9695,14 @@ fn aiur_fn_76(
             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_76] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
-            record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
             let __v_30: G = G::from_u64(1);
             let __v_31: G = (__v_29 + __v_30);
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_31]; 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_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];
@@ -10382,8 +9712,8 @@ fn aiur_fn_76(
             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_76] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
-            record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -10395,15 +9725,15 @@ fn aiur_fn_76(
   })
 }
 
-const INPUT_SIZE_77: usize = 1;
-const IN_77: usize = 1;
-const OUT_77: usize = 10;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+const INPUT_SIZE_69: usize = 1;
+const IN_69: usize = 1;
+const OUT_69: usize = 10;
+fn aiur_fn_69(
+  inp: [G; IN_69],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_77], ExecError> {
+) -> Result<[G; OUT_69], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -10445,14 +9775,14 @@ fn aiur_fn_77(
             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_77] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; 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_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 __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -10462,8 +9792,8 @@ fn aiur_fn_77(
             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_77] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -10475,15 +9805,15 @@ 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_70: usize = 1;
+const IN_70: usize = 1;
+const OUT_70: usize = 10;
+fn aiur_fn_70(
+  inp: [G; IN_70],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_78], 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 };
@@ -10525,14 +9855,14 @@ fn aiur_fn_78(
             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_78] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; 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_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 __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -10542,8 +9872,8 @@ fn aiur_fn_78(
             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_78] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -10555,15 +9885,15 @@ fn aiur_fn_78(
   })
 }
 
-const INPUT_SIZE_79: usize = 9;
-const IN_79: usize = 9;
-const OUT_79: usize = 2;
-fn aiur_fn_79(
-  inp: [G; IN_79],
+const INPUT_SIZE_71: usize = 9;
+const IN_71: usize = 9;
+const OUT_71: usize = 2;
+fn aiur_fn_71(
+  inp: [G; IN_71],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_79], ExecError> {
+) -> Result<[G; OUT_71], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10581,12 +9911,12 @@ fn aiur_fn_79(
         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_79] = [__v_12, __v_0];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_71] = [__v_12, __v_0];
+        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -10596,7 +9926,7 @@ fn aiur_fn_79(
         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_17] = { let __args: [G; IN_17] = [__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[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_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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -10605,13 +9935,13 @@ fn aiur_fn_79(
         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_79] = { let __args: [G; IN_79] = [__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[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_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 __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_79] = [__v_30, __v_28];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_71] = [__v_30, __v_28];
+        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10621,15 +9951,15 @@ fn aiur_fn_79(
   })
 }
 
-const INPUT_SIZE_80: usize = 10;
-const IN_80: usize = 10;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
+const INPUT_SIZE_72: usize = 10;
+const IN_72: usize = 10;
+const OUT_72: usize = 2;
+fn aiur_fn_72(
+  inp: [G; IN_72],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
+) -> Result<[G; OUT_72], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10645,18 +9975,18 @@ fn aiur_fn_80(
     let __v_10: G = __r_arr[0];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_80] = [__v_0, __v_1];
-        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_72] = [__v_0, __v_1];
+        record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_1]; 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_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 __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_17] = { let __args: [G; IN_17] = [__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[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_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 __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
         let __v_18: G = __r_arr[2];
@@ -10665,11 +9995,11 @@ fn aiur_fn_80(
         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_80] = { let __args: [G; IN_80] = [__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[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_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 __v_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __ret: [G; OUT_80] = [__v_24, __v_25];
-        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_72] = [__v_24, __v_25];
+        record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10679,15 +10009,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_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_81], 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];
@@ -10702,18 +10032,18 @@ fn aiur_fn_81(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_81] = [__v_10, __v_11];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_73] = [__v_10, __v_11];
+        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -10722,14 +10052,14 @@ fn aiur_fn_81(
         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_81] = { let __args: [G; IN_81] = [__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[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_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 __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_81] = [__v_24, __v_21];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_73] = [__v_24, __v_21];
+        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10739,15 +10069,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_74: usize = 9;
+const IN_74: usize = 9;
+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_82], 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];
@@ -10762,18 +10092,18 @@ fn aiur_fn_82(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_82] = [__v_10, __v_11];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_10, __v_11];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -10782,14 +10112,14 @@ 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_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 __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_82] = [__v_24, __v_21];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_24, __v_21];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10799,18 +10129,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_75: usize = 1;
+const IN_75: usize = 1;
+const OUT_75: usize = 2;
+fn aiur_fn_75(
+  inp: [G; IN_75],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_83], ExecError> {
+) -> Result<[G; OUT_75], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_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];
@@ -10826,20 +10156,20 @@ fn aiur_fn_83(
         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_83] = [__v_13, __v_10];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_13, __v_10];
+        record.function_queries[75].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_83] = [__v_13, __v_10];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_13, __v_10];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10849,18 +10179,18 @@ fn aiur_fn_83(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __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 __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 __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_83] = [__v_24, __v_21];
-        record.function_queries[83].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);
       },
       3u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10870,18 +10200,18 @@ fn aiur_fn_83(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __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 __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 __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_83] = [__v_24, __v_21];
-        record.function_queries[83].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);
       },
       4u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10891,72 +10221,72 @@ fn aiur_fn_83(
         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_83] = { let __args: [G; IN_83] = [__v_19]; 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_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 __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_83] = [__v_23, __v_21];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_23, __v_21];
+        record.function_queries[75].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_83] = [__v_13, __v_10];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_13, __v_10];
+        record.function_queries[75].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_83] = [__v_13, __v_10];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_13, __v_10];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__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[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_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 __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_83] = [__v_13, __v_14];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_13, __v_14];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__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[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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_83] = [__v_11, __v_12];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_11, __v_12];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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[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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_83] = [__v_11, __v_12];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_11, __v_12];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__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[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_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_83] = [__v_11, __v_12];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_11, __v_12];
+        record.function_queries[75].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_83] = [__v_13, __v_10];
-        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_13, __v_10];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10966,15 +10296,15 @@ fn aiur_fn_83(
   })
 }
 
-const INPUT_SIZE_84: usize = 9;
-const IN_84: usize = 9;
-const OUT_84: usize = 2;
-fn aiur_fn_84(
-  inp: [G; IN_84],
+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_84], 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];
@@ -10985,33 +10315,33 @@ fn aiur_fn_84(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_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 __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_12]; 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_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 __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_84] = [__v_17, __v_14];
-    record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_76] = [__v_17, __v_14];
+    record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_85: usize = 17;
-const IN_85: usize = 17;
-const OUT_85: usize = 9;
-fn aiur_fn_85(
-  inp: [G; IN_85],
+const INPUT_SIZE_77: usize = 17;
+const IN_77: usize = 17;
+const OUT_77: usize = 9;
+fn aiur_fn_77(
+  inp: [G; IN_77],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
+) -> Result<[G; OUT_77], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11034,12 +10364,12 @@ fn aiur_fn_85(
     let __v_17: G = __r_arr[0];
     match __v_17.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_85] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_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[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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -11048,7 +10378,7 @@ fn aiur_fn_85(
         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_85] = { let __args: [G; IN_85] = [__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[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_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 __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -11061,8 +10391,8 @@ fn aiur_fn_85(
         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_85] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
-        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -11072,18 +10402,18 @@ fn aiur_fn_85(
   })
 }
 
-const INPUT_SIZE_86: usize = 1;
-const IN_86: usize = 1;
-const OUT_86: usize = 10;
-fn aiur_fn_86(
-  inp: [G; IN_86],
+const INPUT_SIZE_78: usize = 1;
+const IN_78: usize = 1;
+const OUT_78: usize = 10;
+fn aiur_fn_78(
+  inp: [G; IN_78],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_86], ExecError> {
+) -> Result<[G; OUT_78], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !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_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11102,12 +10432,12 @@ fn aiur_fn_86(
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_86] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
-            record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
@@ -11118,7 +10448,7 @@ fn aiur_fn_86(
             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_85] = { let __args: [G; IN_85] = [__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[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_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 __v_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
             let __v_24: G = __r_arr[2];
@@ -11128,8 +10458,8 @@ fn aiur_fn_86(
             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_86] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
-            record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -11138,7 +10468,7 @@ fn aiur_fn_86(
         }
       },
       1u64 => {
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11149,7 +10479,7 @@ fn aiur_fn_86(
         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_86] = { let __args: [G; IN_86] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -11164,12 +10494,12 @@ fn aiur_fn_86(
         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_86] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11180,7 +10510,7 @@ fn aiur_fn_86(
         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_86] = { let __args: [G; IN_86] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -11195,14 +10525,14 @@ fn aiur_fn_86(
         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_86] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_86] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -11212,15 +10542,15 @@ fn aiur_fn_86(
   })
 }
 
-const INPUT_SIZE_87: usize = 1;
-const IN_87: usize = 1;
-const OUT_87: usize = 2;
-fn aiur_fn_87(
-  inp: [G; IN_87],
+const INPUT_SIZE_79: usize = 1;
+const IN_79: usize = 1;
+const OUT_79: usize = 2;
+fn aiur_fn_79(
+  inp: [G; IN_79],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_87], ExecError> {
+) -> Result<[G; OUT_79], 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 };
@@ -11416,8 +10746,8 @@ fn aiur_fn_87(
                                                                                                                                 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_87] = [__v_97, __v_96];
-                                                                                                                                    record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                    let __ret: [G; OUT_79] = [__v_97, __v_96];
+                                                                                                                                    record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                     return Ok(__ret);
                                                                                                                                   },
                                                                                                                                   _ => {
@@ -11582,15 +10912,15 @@ fn aiur_fn_87(
   })
 }
 
-const INPUT_SIZE_88: usize = 9;
-const IN_88: usize = 9;
-const OUT_88: usize = 2;
-fn aiur_fn_88(
-  inp: [G; IN_88],
+const INPUT_SIZE_80: usize = 9;
+const IN_80: usize = 9;
+const OUT_80: usize = 2;
+fn aiur_fn_80(
+  inp: [G; IN_80],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_88], ExecError> {
+) -> Result<[G; OUT_80], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11608,15 +10938,15 @@ fn aiur_fn_88(
         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_88] = [__v_12, __v_0];
-        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_12, __v_0];
+        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -11625,13 +10955,13 @@ fn aiur_fn_88(
         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_88] = { let __args: [G; IN_88] = [__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[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_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 __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_88] = [__v_23, __v_21];
-        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_23, __v_21];
+        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11641,15 +10971,15 @@ fn aiur_fn_88(
   })
 }
 
-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_81: usize = 9;
+const IN_81: usize = 9;
+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_89], ExecError> {
+) -> Result<[G; OUT_81], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11667,12 +10997,12 @@ fn aiur_fn_89(
         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_89] = [__v_12, __v_0];
-        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_81] = [__v_12, __v_0];
+        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11683,7 +11013,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_17] = { let __args: [G; IN_17] = [__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[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_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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -11692,14 +11022,14 @@ 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_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 __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_89] = [__v_32, __v_29];
-        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_81] = [__v_32, __v_29];
+        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11709,15 +11039,15 @@ fn aiur_fn_89(
   })
 }
 
-const INPUT_SIZE_90: usize = 9;
-const IN_90: usize = 9;
-const OUT_90: usize = 2;
-fn aiur_fn_90(
-  inp: [G; IN_90],
+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_90], 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];
@@ -11735,15 +11065,15 @@ fn aiur_fn_90(
         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_90] = [__v_12, __v_0];
-        record.function_queries[90].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_87] = { let __args: [G; IN_87] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -11752,13 +11082,13 @@ fn aiur_fn_90(
         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_90] = { let __args: [G; IN_90] = [__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[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_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_90] = [__v_23, __v_21];
-        record.function_queries[90].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);
       },
       _ => {
@@ -11768,18 +11098,18 @@ fn aiur_fn_90(
   })
 }
 
-const INPUT_SIZE_91: usize = 1;
-const IN_91: usize = 1;
-const OUT_91: usize = 2;
-fn aiur_fn_91(
-  inp: [G; IN_91],
+const INPUT_SIZE_83: usize = 1;
+const IN_83: usize = 1;
+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_91], ExecError> {
+) -> Result<[G; OUT_83], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -11789,27 +11119,27 @@ fn aiur_fn_91(
     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_88] = { let __args: [G; IN_88] = [__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[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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_91] = [__v_10, __v_11];
-    record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_83] = [__v_10, __v_11];
+    record.function_queries[83].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 = 2;
-fn aiur_fn_92(
-  inp: [G; IN_92],
+const INPUT_SIZE_84: usize = 1;
+const IN_84: usize = 1;
+const OUT_84: usize = 2;
+fn aiur_fn_84(
+  inp: [G; IN_84],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_92], ExecError> {
+) -> Result<[G; OUT_84], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -11819,27 +11149,27 @@ fn aiur_fn_92(
     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_90] = { let __args: [G; IN_90] = [__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[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_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_92] = [__v_10, __v_11];
-    record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_84] = [__v_10, __v_11];
+    record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_93: usize = 1;
-const IN_93: usize = 1;
-const OUT_93: usize = 2;
-fn aiur_fn_93(
-  inp: [G; IN_93],
+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_93], 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_76] = { let __args: [G; IN_76] = [__v_0]; 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_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];
@@ -11849,88 +11179,88 @@ fn aiur_fn_93(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9, __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[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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_93] = [__v_10, __v_11];
-    record.function_queries[93].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_94: usize = 1;
-const IN_94: usize = 1;
-const OUT_94: usize = 2;
-fn aiur_fn_94(
-  inp: [G; IN_94],
+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_94], ExecError> {
+) -> Result<[G; OUT_86], 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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].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_94] = [__v_1, __v_2];
-        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_86] = [__v_1, __v_2];
+        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11940,24 +11270,24 @@ fn aiur_fn_94(
   })
 }
 
-const INPUT_SIZE_95: usize = 1;
-const IN_95: usize = 1;
-const OUT_95: usize = 13;
-fn aiur_fn_95(
-  inp: [G; IN_95],
+const INPUT_SIZE_87: usize = 1;
+const IN_87: usize = 1;
+const OUT_87: usize = 13;
+fn aiur_fn_87(
+  inp: [G; IN_87],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_95], 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_74] = { let __args: [G; IN_74] = [__v_0]; 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_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_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 __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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = __r_arr[2];
@@ -11967,30 +11297,30 @@ fn aiur_fn_95(
     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_83] = { let __args: [G; IN_83] = [__v_13]; 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_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 __v_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_15]; 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_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 __v_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
-    let __ret: [G; OUT_95] = [__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[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_96: usize = 1;
-const IN_96: usize = 1;
-const OUT_96: usize = 10;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_88: usize = 1;
+const IN_88: usize = 1;
+const OUT_88: usize = 10;
+fn aiur_fn_88(
+  inp: [G; IN_88],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_88], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -12000,24 +11330,24 @@ fn aiur_fn_96(
     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_83] = { let __args: [G; IN_83] = [__v_9]; 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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_96] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_97: usize = 9;
-const IN_97: usize = 9;
-const OUT_97: usize = 2;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_89: usize = 9;
+const IN_89: usize = 9;
+const OUT_89: usize = 2;
+fn aiur_fn_89(
+  inp: [G; IN_89],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_89], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12035,12 +11365,12 @@ fn aiur_fn_97(
         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_97] = [__v_12, __v_0];
-        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_89] = [__v_12, __v_0];
+        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12051,7 +11381,7 @@ fn aiur_fn_97(
         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_17] = { let __args: [G; IN_17] = [__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[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_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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -12060,13 +11390,13 @@ fn aiur_fn_97(
         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_97] = { let __args: [G; IN_97] = [__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[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_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 __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_97] = [__v_31, __v_29];
-        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_89] = [__v_31, __v_29];
+        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12076,18 +11406,18 @@ fn aiur_fn_97(
   })
 }
 
-const INPUT_SIZE_98: usize = 1;
-const IN_98: usize = 1;
-const OUT_98: usize = 45;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_90: usize = 1;
+const IN_90: usize = 1;
+const OUT_90: usize = 45;
+fn aiur_fn_90(
+  inp: [G; IN_90],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], 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_74] = { let __args: [G; IN_74] = [__v_0]; 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_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 __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) };
@@ -12099,7 +11429,7 @@ fn aiur_fn_98(
     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_76] = { let __args: [G; IN_76] = [__v_2]; 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_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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12109,7 +11439,7 @@ fn aiur_fn_98(
     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_76] = { let __args: [G; IN_76] = [__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 __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 __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -12119,7 +11449,7 @@ fn aiur_fn_98(
     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_76] = { let __args: [G; IN_76] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -12129,7 +11459,7 @@ fn aiur_fn_98(
     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_76] = { let __args: [G; IN_76] = [__v_37]; 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_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 __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -12139,7 +11469,7 @@ fn aiur_fn_98(
     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_76] = { let __args: [G; IN_76] = [__v_46]; 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_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 __v_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __v_49: G = __r_arr[2];
@@ -12149,10 +11479,10 @@ fn aiur_fn_98(
     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_83] = { let __args: [G; IN_83] = [__v_55]; 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_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 __v_56: G = __r_arr[0];
     let __v_57: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_57]; 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_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 __v_58: G = __r_arr[0];
     let __v_59: G = __r_arr[1];
     let __v_60: G = __r_arr[2];
@@ -12162,30 +11492,30 @@ fn aiur_fn_98(
     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_97] = { let __args: [G; IN_97] = [__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[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_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 __v_67: G = __r_arr[0];
     let __v_68: G = __r_arr[1];
-    let __ret: [G; OUT_98] = [__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[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_99: usize = 1;
-const IN_99: usize = 1;
-const OUT_99: usize = 11;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_91: usize = 1;
+const IN_91: usize = 1;
+const OUT_91: usize = 11;
+fn aiur_fn_91(
+  inp: [G; IN_91],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_91], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !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_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_76] = { let __args: [G; IN_76] = [__v_2]; 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_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];
@@ -12195,49 +11525,49 @@ fn aiur_fn_99(
     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_83] = { let __args: [G; IN_83] = [__v_11]; 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_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 __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
-    let __ret: [G; OUT_99] = [__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[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_100: usize = 1;
-const IN_100: usize = 1;
-const OUT_100: usize = 1;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_92: usize = 1;
+const IN_92: usize = 1;
+const OUT_92: usize = 1;
+fn aiur_fn_92(
+  inp: [G; IN_92],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> Result<[G; OUT_92], 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_100] = [__v_1];
-        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_92] = [__v_1];
+        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_100] = [__v_1];
-        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_92] = [__v_1];
+        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_100] = [__v_1];
-        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_92] = [__v_1];
+        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(3);
-        let __ret: [G; OUT_100] = [__v_1];
-        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_92] = [__v_1];
+        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12247,23 +11577,23 @@ fn aiur_fn_100(
   })
 }
 
-const INPUT_SIZE_101: usize = 1;
-const IN_101: usize = 1;
-const OUT_101: usize = 11;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+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_101], 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_74] = { let __args: [G; IN_74] = [__v_0]; 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_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_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 __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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -12273,30 +11603,30 @@ fn aiur_fn_101(
     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_83] = { let __args: [G; IN_83] = [__v_12]; 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_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 __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __ret: [G; OUT_101] = [__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[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_102: usize = 1;
-const IN_102: usize = 1;
-const OUT_102: usize = 35;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 35;
+fn aiur_fn_94(
+  inp: [G; IN_94],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_94], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !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_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_76] = { let __args: [G; IN_76] = [__v_2]; 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_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];
@@ -12306,7 +11636,7 @@ fn aiur_fn_102(
     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_76] = { let __args: [G; IN_76] = [__v_11]; 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_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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -12316,7 +11646,7 @@ fn aiur_fn_102(
     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_76] = { let __args: [G; IN_76] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -12326,7 +11656,7 @@ fn aiur_fn_102(
     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_76] = { let __args: [G; IN_76] = [__v_29]; 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_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 __v_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = __r_arr[2];
@@ -12336,24 +11666,24 @@ fn aiur_fn_102(
     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_83] = { let __args: [G; IN_83] = [__v_38]; 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_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 __v_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
-    let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_103: usize = 9;
-const IN_103: usize = 9;
-const OUT_103: usize = 2;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_95: usize = 9;
+const IN_95: usize = 9;
+const OUT_95: usize = 2;
+fn aiur_fn_95(
+  inp: [G; IN_95],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_95], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12371,12 +11701,12 @@ fn aiur_fn_103(
         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_103] = [__v_12, __v_0];
-        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_95] = [__v_12, __v_0];
+        record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; 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_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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12412,7 +11742,7 @@ fn aiur_fn_103(
         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_17] = { let __args: [G; IN_17] = [__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[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_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_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -12421,13 +11751,13 @@ fn aiur_fn_103(
         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_103] = { let __args: [G; IN_103] = [__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[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 __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 __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_103] = [__v_56, __v_54];
-        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_95] = [__v_56, __v_54];
+        record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12437,18 +11767,18 @@ fn aiur_fn_103(
   })
 }
 
-const INPUT_SIZE_104: usize = 1;
-const IN_104: usize = 1;
-const OUT_104: usize = 28;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_96: usize = 1;
+const IN_96: usize = 1;
+const OUT_96: usize = 28;
+fn aiur_fn_96(
+  inp: [G; IN_96],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], 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_74] = { let __args: [G; IN_74] = [__v_0]; 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_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 __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) };
@@ -12460,7 +11790,7 @@ fn aiur_fn_104(
     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_76] = { let __args: [G; IN_76] = [__v_2]; 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_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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12470,7 +11800,7 @@ fn aiur_fn_104(
     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_76] = { let __args: [G; IN_76] = [__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 __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 __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -12480,7 +11810,7 @@ fn aiur_fn_104(
     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_76] = { let __args: [G; IN_76] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -12490,10 +11820,10 @@ fn aiur_fn_104(
     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_83] = { let __args: [G; IN_83] = [__v_37]; 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_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 __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_39]; 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_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 __v_40: G = __r_arr[0];
     let __v_41: G = __r_arr[1];
     let __v_42: G = __r_arr[2];
@@ -12503,27 +11833,27 @@ fn aiur_fn_104(
     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_103] = { let __args: [G; IN_103] = [__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[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 __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 __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __ret: [G; OUT_104] = [__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[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_105: usize = 1;
-const IN_105: usize = 1;
-const OUT_105: usize = 10;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_97: usize = 1;
+const IN_97: usize = 1;
+const OUT_97: usize = 10;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
+) -> Result<[G; OUT_97], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -12533,27 +11863,27 @@ fn aiur_fn_105(
     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_87] = { let __args: [G; IN_87] = [__v_9]; 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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_106: usize = 1;
-const IN_106: usize = 1;
-const OUT_106: usize = 18;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_98: usize = 1;
+const IN_98: usize = 1;
+const OUT_98: usize = 18;
+fn aiur_fn_98(
+  inp: [G; IN_98],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], 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_76] = { let __args: [G; IN_76] = [__v_0]; 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_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];
@@ -12563,7 +11893,7 @@ fn aiur_fn_106(
     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_76] = { let __args: [G; IN_76] = [__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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -12573,32 +11903,32 @@ fn aiur_fn_106(
     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_87] = { let __args: [G; IN_87] = [__v_18]; 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_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 __v_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __ret: [G; OUT_106] = [__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[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 46;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_99: usize = 1;
+const IN_99: usize = 1;
+const OUT_99: usize = 46;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], 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_74] = { let __args: [G; IN_74] = [__v_0]; 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_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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12614,12 +11944,12 @@ fn aiur_fn_107(
         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_107] = [__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[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       1u64 => {
-        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 __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 __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12650,12 +11980,12 @@ fn aiur_fn_107(
         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_107] = [__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[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        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 __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 __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12702,8 +12032,8 @@ fn aiur_fn_107(
         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_107] = [__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[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -12713,15 +12043,15 @@ fn aiur_fn_107(
   })
 }
 
-const INPUT_SIZE_108: usize = 9;
-const IN_108: usize = 9;
-const OUT_108: usize = 2;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+const INPUT_SIZE_100: usize = 9;
+const IN_100: usize = 9;
+const OUT_100: usize = 2;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_100], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12739,12 +12069,12 @@ fn aiur_fn_108(
         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_108] = [__v_12, __v_0];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_100] = [__v_12, __v_0];
+        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12791,7 +12121,7 @@ fn aiur_fn_108(
         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_17] = { let __args: [G; IN_17] = [__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[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_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_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -12800,13 +12130,13 @@ fn aiur_fn_108(
         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_108] = { let __args: [G; IN_108] = [__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[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 __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 __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_108] = [__v_67, __v_65];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_100] = [__v_67, __v_65];
+        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12816,21 +12146,21 @@ fn aiur_fn_108(
   })
 }
 
-const INPUT_SIZE_109: usize = 2;
-const IN_109: usize = 2;
-const OUT_109: usize = 46;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_101: usize = 2;
+const IN_101: usize = 2;
+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_109], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        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 __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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12846,12 +12176,12 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       1u64 => {
-        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_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12898,12 +12228,12 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        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 __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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12917,12 +12247,12 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; 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_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];
@@ -12936,12 +12266,12 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       4u64 => {
-        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 __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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12962,12 +12292,12 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__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 __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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12980,12 +12310,12 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__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 __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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12998,12 +12328,12 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__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 __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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13016,8 +12346,8 @@ fn aiur_fn_109(
         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_109] = [__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[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -13027,15 +12357,15 @@ fn aiur_fn_109(
   })
 }
 
-const INPUT_SIZE_110: usize = 10;
-const IN_110: usize = 10;
-const OUT_110: usize = 46;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_102: usize = 10;
+const IN_102: usize = 10;
+const OUT_102: usize = 46;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_110], 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];
@@ -13049,17 +12379,17 @@ fn aiur_fn_110(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       12u64 => {
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__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[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 __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 __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_110] = [__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[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       13u64 => {
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1, __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 __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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -13106,8 +12436,8 @@ fn aiur_fn_110(
         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_110] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -13117,18 +12447,18 @@ fn aiur_fn_110(
   })
 }
 
-const INPUT_SIZE_111: usize = 1;
-const IN_111: usize = 1;
-const OUT_111: usize = 49;
-fn aiur_fn_111(
-  inp: [G; IN_111],
+const INPUT_SIZE_103: usize = 1;
+const IN_103: usize = 1;
+const OUT_103: usize = 49;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_111], ExecError> {
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_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];
@@ -13139,7 +12469,7 @@ fn aiur_fn_111(
     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_110] = { let __args: [G; IN_110] = [__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[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 __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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -13186,30 +12516,30 @@ fn aiur_fn_111(
     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_91] = { let __args: [G; IN_91] = [__v_56]; 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_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 __v_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_58]; 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_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 __v_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
-    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_60]; 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_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 __v_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
-    let __ret: [G; OUT_111] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_112: usize = 1;
-const IN_112: usize = 1;
-const OUT_112: usize = 1;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_104: usize = 1;
+const IN_104: usize = 1;
+const OUT_104: usize = 1;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_112], ExecError> {
+) -> Result<[G; OUT_104], 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 };
@@ -13227,50 +12557,50 @@ fn aiur_fn_112(
         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_112] = [__v_12];
-        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_112] = { let __args: [G; IN_112] = [__v_2]; 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_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_112] = [__v_13];
-        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_112] = { let __args: [G; IN_112] = [__v_2]; 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_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_112] = { let __args: [G; IN_112] = [__v_3]; 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_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_112] = [__v_13];
-        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_112] = { let __args: [G; IN_112] = [__v_2]; 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_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_112] = { let __args: [G; IN_112] = [__v_3]; 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_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_112] = [__v_13];
-        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_18] = { let __args: [G; IN_18] = [__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[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_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_112] = [__v_13];
-        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_104] = [__v_13];
+        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13280,15 +12610,15 @@ fn aiur_fn_112(
   })
 }
 
-const INPUT_SIZE_113: usize = 2;
-const IN_113: usize = 2;
-const OUT_113: usize = 1;
-fn aiur_fn_113(
-  inp: [G; IN_113],
+const INPUT_SIZE_105: usize = 2;
+const IN_105: usize = 2;
+const OUT_105: usize = 1;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_113], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13308,23 +12638,23 @@ fn aiur_fn_113(
         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_113] = [__v_14];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_105] = [__v_14];
+        record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_781] = { let __args: [G; IN_781] = [__v_1, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_12]; 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 __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; 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_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_113] = { let __args: [G; IN_113] = [__v_11, __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 __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_113] = [__v_17];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_105] = [__v_17];
+        record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13334,15 +12664,15 @@ fn aiur_fn_113(
   })
 }
 
-const INPUT_SIZE_114: usize = 1;
-const IN_114: usize = 1;
-const OUT_114: usize = 1;
-fn aiur_fn_114(
-  inp: [G; IN_114],
+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_114], ExecError> {
+) -> 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);
@@ -13354,7 +12684,7 @@ fn aiur_fn_114(
     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_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13364,7 +12694,7 @@ fn aiur_fn_114(
     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_116] = { let __args: [G; IN_116] = [__v_0, __v_18]; 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 __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];
@@ -13379,8 +12709,8 @@ fn aiur_fn_114(
             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_114] = [__v_26];
-            record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_106] = [__v_26];
+            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -13389,8 +12719,8 @@ fn aiur_fn_114(
             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_114] = [__v_28];
-            record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_106] = [__v_28];
+            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13399,27 +12729,27 @@ fn aiur_fn_114(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_19]; 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 __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_114] = [__v_25];
-        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_106] = [__v_25];
+        record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_115: usize = 10;
-const IN_115: usize = 10;
-const OUT_115: usize = 8;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_107: usize = 10;
+const IN_107: usize = 10;
+const OUT_107: usize = 8;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_115], 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];
@@ -13433,8 +12763,8 @@ fn aiur_fn_115(
     let __v_9: G = inp[9];
     match __v_9.as_canonical_u64() {
       8u64 => {
-        let __ret: [G; OUT_115] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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);
       },
       _ => {
@@ -13444,15 +12774,15 @@ fn aiur_fn_115(
         let __v_12: G = __loaded[2];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_115] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-            record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
           0u64 => {
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13461,13 +12791,13 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13476,13 +12806,13 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13491,13 +12821,13 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13506,13 +12836,13 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13521,13 +12851,13 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13536,13 +12866,13 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13551,13 +12881,13 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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);
               },
               _ => {
                 let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__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[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 __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];
@@ -13566,8 +12896,8 @@ fn aiur_fn_115(
                 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_115] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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);
               },
             }
@@ -13581,22 +12911,22 @@ fn aiur_fn_115(
   })
 }
 
-const INPUT_SIZE_116: usize = 2;
-const IN_116: usize = 2;
-const OUT_116: usize = 1;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+const INPUT_SIZE_108: usize = 2;
+const IN_108: usize = 2;
+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_116], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_116] = [__v_0];
-        record.function_queries[116].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);
       },
       _ => {
@@ -13609,17 +12939,17 @@ fn aiur_fn_116(
             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_116] = [__v_7];
-            record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_116] = { let __args: [G; IN_116] = [__v_4, __v_6]; 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 __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_116] = [__v_7];
-            record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_108] = [__v_7];
+            record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13631,15 +12961,15 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 6;
-const IN_117: usize = 6;
-const OUT_117: usize = 1;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+const INPUT_SIZE_109: usize = 6;
+const IN_109: usize = 6;
+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_117], 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];
@@ -13668,149 +12998,149 @@ fn aiur_fn_117(
     let __v_23: G = __loaded[17];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_781] = { let __args: [G; IN_781] = [__v_5, __v_24]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_24]; 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 __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(1);
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_25]; 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_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_117] = [__v_29];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_18] = { let __args: [G; IN_18] = [__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[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_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_117] = [__v_27];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_18] = { let __args: [G; IN_18] = [__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[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_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_781] = { let __args: [G; IN_781] = [__v_2, __v_24]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_24]; 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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_15, __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 __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_117] = [__v_29];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_18] = { let __args: [G; IN_18] = [__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[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_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_781] = { let __args: [G; IN_781] = [__v_3, __v_24]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_24]; 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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_15, __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 __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_117] = [__v_29];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_18] = { let __args: [G; IN_18] = [__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[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_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_781] = { let __args: [G; IN_781] = [__v_2, __v_24]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_24]; 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 __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(8);
-        let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_117] = { let __args: [G; IN_117] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = [__v_29];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_782] = { let __args: [G; IN_782] = [__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[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_752] = { let __args: [G; IN_752] = [__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[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 __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_117] = [__v_28];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_782] = { let __args: [G; IN_782] = [__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[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_752] = { let __args: [G; IN_752] = [__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[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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_24]; 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 __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_117] = [__v_29];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_117] = { let __args: [G; IN_117] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = { let __args: [G; IN_117] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = [__v_28];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_117] = { let __args: [G; IN_117] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = { let __args: [G; IN_117] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = [__v_28];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_117] = { let __args: [G; IN_117] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = { let __args: [G; IN_117] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = [__v_28];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_117] = { let __args: [G; IN_117] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = { let __args: [G; IN_117] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = { let __args: [G; IN_117] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = [__v_28];
-        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_18] = { let __args: [G; IN_18] = [__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[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_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_799] = { let __args: [G; IN_799] = [__v_1, __v_24]; 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_769] = { let __args: [G; IN_769] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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];
@@ -13818,10 +13148,10 @@ fn aiur_fn_117(
         let __v_28: G = __loaded[2];
         match __v_26.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __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_117] = [__v_29];
-            record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_109] = [__v_29];
+            record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13836,15 +13166,15 @@ fn aiur_fn_117(
   })
 }
 
-const INPUT_SIZE_118: usize = 7;
-const IN_118: usize = 7;
-const OUT_118: usize = 1;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_110: usize = 7;
+const IN_110: usize = 7;
+const OUT_110: usize = 1;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_118], 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];
@@ -13870,8 +13200,8 @@ fn aiur_fn_118(
         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_118] = [__v_20];
-        record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_110] = [__v_20];
+        record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -13885,16 +13215,16 @@ fn aiur_fn_118(
               0u64 => {
                 match __v_2.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __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_18] = { let __args: [G; IN_18] = [__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[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_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_118] = { let __args: [G; IN_118] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __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_118] = [__v_25];
-                    record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_110] = [__v_25];
+                    record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -13913,15 +13243,15 @@ fn aiur_fn_118(
   })
 }
 
-const INPUT_SIZE_119: usize = 18;
-const IN_119: usize = 18;
-const OUT_119: usize = 11;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+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_119], 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];
@@ -13945,51 +13275,51 @@ fn aiur_fn_119(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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_117] = { let __args: [G; IN_117] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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 __v_20: G = G::from_u64(1);
-                let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_119] = [__v_20, __v_21, __v_18, __v_19, __v_1, __v_17, __v_22, __v_22, __v_22, __v_22, __v_22];
-                record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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];
+                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_18] = { let __args: [G; IN_18] = [__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[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_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_119] = [__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[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_18] = { let __args: [G; IN_18] = [__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[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_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_119] = [__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[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_18] = { let __args: [G; IN_18] = [__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[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_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_119] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
-                record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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];
+                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -14003,15 +13333,15 @@ fn aiur_fn_119(
   })
 }
 
-const INPUT_SIZE_120: usize = 15;
-const IN_120: usize = 15;
-const OUT_120: usize = 11;
-fn aiur_fn_120(
-  inp: [G; IN_120],
+const INPUT_SIZE_112: usize = 15;
+const IN_112: usize = 15;
+const OUT_112: usize = 11;
+fn aiur_fn_112(
+  inp: [G; IN_112],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
+) -> 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];
@@ -14032,14 +13362,14 @@ fn aiur_fn_120(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 __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_18] = { let __args: [G; IN_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[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_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_120] = [__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[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
         }
@@ -14048,15 +13378,15 @@ fn aiur_fn_120(
   })
 }
 
-const INPUT_SIZE_121: usize = 15;
-const IN_121: usize = 15;
-const OUT_121: usize = 11;
-fn aiur_fn_121(
-  inp: [G; IN_121],
+const INPUT_SIZE_113: usize = 15;
+const IN_113: usize = 15;
+const OUT_113: usize = 11;
+fn aiur_fn_113(
+  inp: [G; IN_113],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
+) -> 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];
@@ -14077,14 +13407,14 @@ fn aiur_fn_121(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 __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_18] = { let __args: [G; IN_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[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_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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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];
+            record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -14093,15 +13423,15 @@ fn aiur_fn_121(
   })
 }
 
-const INPUT_SIZE_122: usize = 51;
-const IN_122: usize = 51;
-const OUT_122: usize = 11;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_114: usize = 51;
+const IN_114: usize = 51;
+const OUT_114: usize = 11;
+fn aiur_fn_114(
+  inp: [G; IN_114],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
+) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14158,23 +13488,23 @@ fn aiur_fn_122(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; 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 __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_118] = { let __args: [G; IN_118] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; 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 __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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_122] = [__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[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
         }
@@ -14183,15 +13513,15 @@ fn aiur_fn_122(
   })
 }
 
-const INPUT_SIZE_123: usize = 34;
-const IN_123: usize = 34;
-const OUT_123: usize = 11;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_115: usize = 34;
+const IN_115: usize = 34;
+const OUT_115: usize = 11;
+fn aiur_fn_115(
+  inp: [G; IN_115],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
+) -> Result<[G; OUT_115], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14231,18 +13561,18 @@ fn aiur_fn_123(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_25, __v_27, __v_28, __v_29, __v_30, __v_31]; 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 __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_18] = { let __args: [G; IN_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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_123] = [__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[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
         }
@@ -14251,15 +13581,15 @@ fn aiur_fn_123(
   })
 }
 
-const INPUT_SIZE_124: usize = 40;
-const IN_124: usize = 40;
-const OUT_124: usize = 11;
-fn aiur_fn_124(
-  inp: [G; IN_124],
+const INPUT_SIZE_116: usize = 40;
+const IN_116: usize = 40;
+const OUT_116: usize = 11;
+fn aiur_fn_116(
+  inp: [G; IN_116],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_124], ExecError> {
+) -> 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];
@@ -14305,20 +13635,20 @@ fn aiur_fn_124(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; 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 __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_18] = { let __args: [G; IN_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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_124] = [__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[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
         }
@@ -14327,15 +13657,15 @@ fn aiur_fn_124(
   })
 }
 
-const INPUT_SIZE_125: usize = 1;
-const IN_125: usize = 1;
-const OUT_125: usize = 11;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+const INPUT_SIZE_117: usize = 1;
+const IN_117: usize = 1;
+const OUT_117: usize = 11;
+fn aiur_fn_117(
+  inp: [G; IN_117],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_125], ExecError> {
+) -> 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 };
@@ -14395,7 +13725,7 @@ fn aiur_fn_125(
       _ => {
         match __v_6.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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[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_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];
@@ -14407,12 +13737,12 @@ fn aiur_fn_125(
             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_125] = [__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[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_120] = { let __args: [G; IN_120] = [__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[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 __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];
@@ -14424,12 +13754,12 @@ fn aiur_fn_125(
             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_125] = [__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[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_121] = { let __args: [G; IN_121] = [__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[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 __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];
@@ -14441,12 +13771,12 @@ fn aiur_fn_125(
             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_125] = [__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[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_122] = { let __args: [G; IN_122] = [__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[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_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];
@@ -14458,12 +13788,12 @@ fn aiur_fn_125(
             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_125] = [__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[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_123] = { let __args: [G; IN_123] = [__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[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 __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];
@@ -14475,12 +13805,12 @@ fn aiur_fn_125(
             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_125] = [__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[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_124] = { let __args: [G; IN_124] = [__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[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 __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];
@@ -14492,8 +13822,8 @@ fn aiur_fn_125(
             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_125] = [__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[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
           _ => {
@@ -14505,15 +13835,15 @@ fn aiur_fn_125(
   })
 }
 
-const INPUT_SIZE_126: usize = 1;
-const IN_126: usize = 1;
-const OUT_126: usize = 1;
-fn aiur_fn_126(
-  inp: [G; IN_126],
+const INPUT_SIZE_118: usize = 1;
+const IN_118: usize = 1;
+const OUT_118: usize = 1;
+fn aiur_fn_118(
+  inp: [G; IN_118],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_126], ExecError> {
+) -> 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 };
@@ -14525,12 +13855,12 @@ fn aiur_fn_126(
         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_126] = [__v_6];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_125] = { let __args: [G; IN_125] = [__v_2]; 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 __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];
@@ -14544,11 +13874,11 @@ fn aiur_fn_126(
         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_126] = { let __args: [G; IN_126] = [__v_3]; 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 __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_126] = [__v_18];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_118] = [__v_18];
+        record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -14558,15 +13888,15 @@ fn aiur_fn_126(
   })
 }
 
-const INPUT_SIZE_127: usize = 1;
-const IN_127: usize = 1;
-const OUT_127: usize = 48;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_119: usize = 1;
+const IN_119: usize = 1;
+const OUT_119: usize = 48;
+fn aiur_fn_119(
+  inp: [G; IN_119],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_127], ExecError> {
+) -> 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 };
@@ -14609,8 +13939,8 @@ fn aiur_fn_127(
     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_22] = { let __args: [G; IN_22] = [__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[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_111] = { let __args: [G; IN_111] = [__v_37]; 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 __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];
@@ -14675,21 +14005,21 @@ fn aiur_fn_127(
     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_127] = [__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[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_128: usize = 1;
-const IN_128: usize = 1;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+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_128], ExecError> {
+) -> 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 };
@@ -14732,22 +14062,22 @@ fn aiur_fn_128(
     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_22] = { let __args: [G; IN_22] = [__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[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 __ret: [G; OUT_128] = [__v_37];
-    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_129: usize = 2;
-const IN_129: usize = 2;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+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_129], 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];
@@ -14911,269 +14241,269 @@ fn aiur_fn_129(
                                                                                                                             match __v_96.as_canonical_u64() {
                                                                                                                               0u64 => {
                                                                                                                                 let __v_97: G = G::from_u64(1);
-                                                                                                                                let __ret: [G; OUT_129] = [__v_97];
-                                                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                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_129] = [__v_97];
-                                                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                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_129] = [__v_97];
-                                                                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                            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_129] = [__v_97];
-                                                                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                        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_129] = [__v_97];
-                                                                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                    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_129] = [__v_97];
-                                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                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_129] = [__v_97];
-                                                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                            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_129] = [__v_97];
-                                                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                        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_129] = [__v_97];
-                                                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                    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_129] = [__v_97];
-                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                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_129] = [__v_97];
-                                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                            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_129] = [__v_97];
-                                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                        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_129] = [__v_97];
-                                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                    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_129] = [__v_97];
-                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                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_129] = [__v_97];
-                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                            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_129] = [__v_97];
-                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                        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_129] = [__v_97];
-                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    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_129] = [__v_97];
-                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                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_129] = [__v_97];
-                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            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_129] = [__v_97];
-                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        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_129] = [__v_97];
-                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    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_129] = [__v_97];
-                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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_129] = [__v_97];
-                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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_129] = [__v_97];
-                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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_129] = [__v_97];
-                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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_129] = [__v_97];
-                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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_129] = [__v_97];
-                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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_129] = [__v_97];
-                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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_129] = [__v_97];
-                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_129] = [__v_97];
-                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_129] = [__v_97];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_129] = [__v_97];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_121] = [__v_97];
+        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_130: usize = 2;
-const IN_130: usize = 2;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+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_130], 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];
@@ -15246,31 +14576,31 @@ fn aiur_fn_130(
     let __v_66: G = (__v_2 - __v_34);
     match __v_66.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __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 __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_130] = [__v_67];
-        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_130] = [__v_67];
-        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_122] = [__v_67];
+        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_131: usize = 1;
-const IN_131: usize = 1;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
+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_131], ExecError> {
+) -> 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 };
@@ -15319,8 +14649,8 @@ fn aiur_fn_131(
     let __v_40: G = __loaded[2];
     match __v_38.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_131] = [__v_39];
-        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_123] = [__v_39];
+        record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15330,32 +14660,32 @@ fn aiur_fn_131(
   })
 }
 
-const INPUT_SIZE_132: usize = 0;
-const IN_132: usize = 0;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
+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_132], ExecError> {
+) -> 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_132] = [__v_0];
-    record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_124] = [__v_0];
+    record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_133: usize = 45;
-const IN_133: usize = 45;
-const OUT_133: usize = 1;
-fn aiur_fn_133(
-  inp: [G; IN_133],
+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_133], 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];
@@ -15406,8 +14736,8 @@ fn aiur_fn_133(
       6u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_133] = [__v_9];
-            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_125] = [__v_9];
+            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15415,8 +14745,8 @@ fn aiur_fn_133(
       4u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_133] = [__v_17];
-            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_125] = [__v_17];
+            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15424,8 +14754,8 @@ fn aiur_fn_133(
       5u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_133] = [__v_9];
-            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_125] = [__v_9];
+            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15433,8 +14763,8 @@ fn aiur_fn_133(
       7u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_133] = [__v_9];
-            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_125] = [__v_9];
+            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15473,8 +14803,8 @@ fn aiur_fn_133(
         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_133] = [__v_77];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_125] = [__v_77];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -15511,8 +14841,8 @@ fn aiur_fn_133(
         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_133] = [__v_77];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_125] = [__v_77];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -15549,8 +14879,8 @@ fn aiur_fn_133(
         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_133] = [__v_77];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_125] = [__v_77];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
@@ -15587,8 +14917,8 @@ fn aiur_fn_133(
         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_133] = [__v_77];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_125] = [__v_77];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
@@ -15625,8 +14955,8 @@ fn aiur_fn_133(
         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_133] = [__v_77];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_125] = [__v_77];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15636,15 +14966,15 @@ fn aiur_fn_133(
   })
 }
 
-const INPUT_SIZE_134: usize = 45;
-const IN_134: usize = 45;
-const OUT_134: usize = 1;
-fn aiur_fn_134(
-  inp: [G; IN_134],
+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_134], ExecError> {
+) -> 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];
@@ -15695,26 +15025,26 @@ fn aiur_fn_134(
       1u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_27]; 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_766] = { let __args: [G; IN_766] = [__v_27]; 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 __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_134] = [__v_47];
-            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_134] = [__v_45];
-        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_134] = [__v_45];
-        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_126] = [__v_45];
+        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15724,15 +15054,15 @@ fn aiur_fn_134(
   })
 }
 
-const INPUT_SIZE_135: usize = 1;
-const IN_135: usize = 1;
-const OUT_135: usize = 1;
-fn aiur_fn_135(
-  inp: [G; IN_135],
+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_135], ExecError> {
+) -> 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 };
@@ -15786,18 +15116,18 @@ fn aiur_fn_135(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_135] = [__v_48];
-        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_134] = { let __args: [G; IN_134] = [__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[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 __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_135] = { let __args: [G; IN_135] = [__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 __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_135] = [__v_50];
-        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_127] = [__v_50];
+        record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15807,23 +15137,23 @@ fn aiur_fn_135(
   })
 }
 
-const INPUT_SIZE_136: usize = 2;
-const IN_136: usize = 2;
-const OUT_136: usize = 1;
-fn aiur_fn_136(
-  inp: [G; IN_136],
+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_136], ExecError> {
+) -> 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_136] = [__v_2];
-        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_128] = [__v_2];
+        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15877,15 +15207,15 @@ fn aiur_fn_136(
         let __v_48: G = __loaded[46];
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__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[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 __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_136] = { let __args: [G; IN_136] = [__v_48, __v_51]; 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 __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_136] = [__v_53];
-            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_128] = [__v_53];
+            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -15897,15 +15227,15 @@ fn aiur_fn_136(
   })
 }
 
-const INPUT_SIZE_137: usize = 2;
-const IN_137: usize = 2;
-const OUT_137: usize = 1;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+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_137], ExecError> {
+) -> 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];
@@ -15916,35 +15246,35 @@ fn aiur_fn_137(
     let __v_5: G = __loaded[3];
     let __v_6: G = __loaded[4];
     let __v_7: G = __loaded[5];
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_754] = { let __args: [G; IN_754] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       4294967295u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_137] = [__v_9];
-        record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_137] = [__v_10];
-        record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_129] = [__v_10];
+        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_138: usize = 2;
-const IN_138: usize = 2;
-const OUT_138: usize = 6;
-fn aiur_fn_138(
-  inp: [G; IN_138],
+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_138], ExecError> {
+) -> 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];
@@ -15956,8 +15286,8 @@ fn aiur_fn_138(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_138] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 => {
@@ -15969,22 +15299,22 @@ fn aiur_fn_138(
           0u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_6 + __v_8);
-            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_4, __v_7]; 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 __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_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_138] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-            record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
           _ => {
@@ -15999,15 +15329,15 @@ fn aiur_fn_138(
   })
 }
 
-const INPUT_SIZE_139: usize = 7;
-const IN_139: usize = 7;
-const OUT_139: usize = 6;
-fn aiur_fn_139(
-  inp: [G; IN_139],
+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_139], ExecError> {
+) -> 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];
@@ -16022,8 +15352,8 @@ fn aiur_fn_139(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_139] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 => {
@@ -16078,22 +15408,22 @@ fn aiur_fn_139(
         let __v_57: G = __loaded[47];
         match __v_10.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __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_139] = { let __args: [G; IN_139] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; 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 __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_139] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69];
-            record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
         }
@@ -16105,15 +15435,15 @@ fn aiur_fn_139(
   })
 }
 
-const INPUT_SIZE_140: usize = 7;
-const IN_140: usize = 7;
-const OUT_140: usize = 6;
-fn aiur_fn_140(
-  inp: [G; IN_140],
+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_140], ExecError> {
+) -> 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];
@@ -16128,46 +15458,46 @@ fn aiur_fn_140(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_140] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __v_11: G = __r_arr[0];
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = []; 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 __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_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_140] = { let __args: [G; IN_140] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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 __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_140] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24];
-            record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_140] = { let __args: [G; IN_140] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __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_140] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17];
-            record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
         }
@@ -16179,42 +15509,42 @@ fn aiur_fn_140(
   })
 }
 
-const INPUT_SIZE_141: usize = 2;
-const IN_141: usize = 2;
-const OUT_141: usize = 6;
-fn aiur_fn_141(
-  inp: [G; IN_141],
+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_141], ExecError> {
+) -> 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_142] = { let __args: [G; IN_142] = [__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[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 __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_141] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_142: usize = 8;
-const IN_142: usize = 8;
-const OUT_142: usize = 6;
-fn aiur_fn_142(
-  inp: [G; IN_142],
+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_142], ExecError> {
+) -> 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];
@@ -16230,8 +15560,8 @@ fn aiur_fn_142(
     let __v_10: G = __loaded[2];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_142] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 => {
@@ -16241,22 +15571,22 @@ fn aiur_fn_142(
         let __v_13: G = __loaded[2];
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_142] = { let __args: [G; IN_142] = [__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[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 __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_142] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-            record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
           _ => {
@@ -16271,15 +15601,15 @@ fn aiur_fn_142(
   })
 }
 
-const INPUT_SIZE_143: usize = 2;
-const IN_143: usize = 2;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
+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_143], ExecError> {
+) -> 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];
@@ -16290,23 +15620,23 @@ fn aiur_fn_143(
     let __v_5: G = __loaded[3];
     let __v_6: G = __loaded[4];
     let __v_7: G = __loaded[5];
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_754] = { let __args: [G; IN_754] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_8: G = __r_arr[0];
-    let __ret: [G; OUT_143] = [__v_8];
-    record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_135] = [__v_8];
+    record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_144: usize = 2;
-const IN_144: usize = 2;
-const OUT_144: usize = 1;
-fn aiur_fn_144(
-  inp: [G; IN_144],
+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_144], ExecError> {
+) -> 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];
@@ -16317,8 +15647,8 @@ fn aiur_fn_144(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_144] = [__v_5];
-        record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_136] = [__v_5];
+        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16326,15 +15656,15 @@ fn aiur_fn_144(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_144] = [__v_6];
-            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_144] = { let __args: [G; IN_144] = [__v_0, __v_4]; 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 __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_144] = [__v_6];
-            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_136] = [__v_6];
+            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16346,15 +15676,15 @@ fn aiur_fn_144(
   })
 }
 
-const INPUT_SIZE_145: usize = 48;
-const IN_145: usize = 48;
-const OUT_145: usize = 1;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+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_145], ExecError> {
+) -> 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];
@@ -16408,19 +15738,19 @@ fn aiur_fn_145(
       _ => {
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1]; 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 __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_145] = [__v_49];
-                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_145] = [__v_49];
-                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_137] = [__v_49];
+                record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -16430,8 +15760,8 @@ fn aiur_fn_145(
           },
           _ => {
             let __v_48: G = G::from_u64(0);
-            let __ret: [G; OUT_145] = [__v_48];
-            record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_137] = [__v_48];
+            record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16440,15 +15770,15 @@ fn aiur_fn_145(
   })
 }
 
-const INPUT_SIZE_146: usize = 1;
-const IN_146: usize = 1;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+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_146], ExecError> {
+) -> 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 };
@@ -16554,45 +15884,45 @@ fn aiur_fn_146(
             match __v_2.as_canonical_u64() {
               1u64 => {
                 let __v_95: G = G::from_u64(1);
-                let __ret: [G; OUT_146] = [__v_95];
-                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_146] = [__v_95];
-                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_146] = [__v_95];
-            record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_146] = [__v_48];
-        record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_138] = [__v_48];
+        record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_147: usize = 3;
-const IN_147: usize = 3;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
+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_147], ExecError> {
+) -> 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];
@@ -16604,8 +15934,8 @@ fn aiur_fn_147(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_147] = [__v_6];
-        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_139] = [__v_6];
+        record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16618,15 +15948,15 @@ fn aiur_fn_147(
             let __v_9: G = (__v_4 - __v_0);
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_147] = [__v_7];
-                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_147] = { let __args: [G; IN_147] = [__v_0, __v_5, __v_8]; 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 __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_147] = [__v_10];
-                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_139] = [__v_10];
+                record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -16643,15 +15973,15 @@ fn aiur_fn_147(
   })
 }
 
-const INPUT_SIZE_148: usize = 3;
-const IN_148: usize = 3;
-const OUT_148: usize = 3;
-fn aiur_fn_148(
-  inp: [G; IN_148],
+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_148], ExecError> {
+) -> 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];
@@ -16662,25 +15992,25 @@ fn aiur_fn_148(
     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_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_2, __v_5, __v_8]; 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 __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_148] = [__v_9, __v_10, __v_11];
-    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_149: usize = 5;
-const IN_149: usize = 5;
-const OUT_149: usize = 3;
-fn aiur_fn_149(
-  inp: [G; IN_149],
+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_149], ExecError> {
+) -> 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];
@@ -16699,8 +16029,8 @@ fn aiur_fn_149(
         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_149] = [__v_10, __v_13, __v_2];
-        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 => {
@@ -16763,7 +16093,7 @@ fn aiur_fn_149(
               _ => {
                 match __v_8.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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 __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 => {
@@ -16771,7 +16101,7 @@ fn aiur_fn_149(
     break '__mc_0 [__v_60];
   },
   _ => {
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_59, __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 __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];
   },
@@ -16780,9 +16110,9 @@ fn aiur_fn_149(
                     let __v_60: G = __mc_out___mc_0[0];
                     match __v_60.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_59, __v_3, __v_4]; 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 __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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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 __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];
@@ -16790,12 +16120,12 @@ fn aiur_fn_149(
                         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_149] = [__v_66, __v_68, __v_64];
-                        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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_135] = { let __args: [G; IN_135] = [__v_9]; 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 __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 => {
@@ -16822,7 +16152,7 @@ fn aiur_fn_149(
  };
                         let __v_63: G = __mc_out___mc_2[0];
                         let __v_64: G = (__v_2 + __v_61);
-                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_64, __v_62, __v_63]; 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 __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];
@@ -16830,8 +16160,8 @@ fn aiur_fn_149(
                         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_149] = [__v_69, __v_71, __v_67];
-                        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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);
                       },
                       _ => {
@@ -16840,83 +16170,83 @@ fn aiur_fn_149(
                     }
                   },
                   6u64 => {
-                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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 __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_149] = [__v_59, __v_60, __v_61];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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 __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_149] = [__v_59, __v_60, __v_61];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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 __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_149] = [__v_59, __v_60, __v_61];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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 __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_149] = [__v_59, __v_60, __v_61];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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 __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_149] = [__v_61, __v_62, __v_63];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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 __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_149] = [__v_61, __v_62, __v_63];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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 __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_149] = [__v_61, __v_62, __v_63];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_149] = { let __args: [G; IN_149] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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 __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_149] = [__v_61, __v_62, __v_63];
-                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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);
                   },
                   _ => {
@@ -16938,15 +16268,15 @@ fn aiur_fn_149(
   })
 }
 
-const INPUT_SIZE_150: usize = 4;
-const IN_150: usize = 4;
-const OUT_150: usize = 1;
-fn aiur_fn_150(
-  inp: [G; IN_150],
+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_150], ExecError> {
+) -> 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];
@@ -16958,23 +16288,23 @@ fn aiur_fn_150(
     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_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; 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 __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_150] = [__v_10];
-    record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_142] = [__v_10];
+    record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_151: usize = 6;
-const IN_151: usize = 6;
-const OUT_151: usize = 1;
-fn aiur_fn_151(
-  inp: [G; IN_151],
+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_151], ExecError> {
+) -> 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];
@@ -16991,8 +16321,8 @@ fn aiur_fn_151(
         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_151] = [__v_11];
-        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_143] = [__v_11];
+        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17055,7 +16385,7 @@ fn aiur_fn_151(
               _ => {
                 match __v_9.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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 __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 => {
@@ -17063,7 +16393,7 @@ fn aiur_fn_151(
     break '__mc_0 [__v_61];
   },
   _ => {
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_60, __v_4]; 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 __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];
   },
@@ -17072,18 +16402,18 @@ fn aiur_fn_151(
                     let __v_61: G = __mc_out___mc_0[0];
                     match __v_61.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_60, __v_4, __v_5]; 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 __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_151] = { let __args: [G; IN_151] = [__v_8, __v_59, __v_2, __v_3, __v_4, __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 __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_151] = [__v_65];
-                        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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_135] = { let __args: [G; IN_135] = [__v_10]; 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 __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 => {
@@ -17111,11 +16441,11 @@ fn aiur_fn_151(
                         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_151] = { let __args: [G; IN_151] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; 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 __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_151] = [__v_68];
-                        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_143] = [__v_68];
+                        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -17126,9 +16456,9 @@ fn aiur_fn_151(
                   6u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_18, __v_2]; 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 __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_127] = { let __args: [G; IN_127] = [__v_18]; 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 __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];
@@ -17181,17 +16511,17 @@ fn aiur_fn_151(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_136] = { let __args: [G; IN_136] = [__v_62, __v_109]; 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 __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_151] = { let __args: [G; IN_151] = [__v_8, __v_59, __v_2, __v_3, __v_4, __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 __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_151] = [__v_114];
-                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_143] = [__v_114];
+                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17206,9 +16536,9 @@ fn aiur_fn_151(
                   4u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_26, __v_2]; 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 __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_127] = { let __args: [G; IN_127] = [__v_26]; 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 __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];
@@ -17261,22 +16591,22 @@ fn aiur_fn_151(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_136] = { let __args: [G; IN_136] = [__v_62, __v_109]; 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 __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_18] = { let __args: [G; IN_18] = [__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[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_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_151] = { let __args: [G; IN_151] = [__v_8, __v_59, __v_2, __v_3, __v_4, __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 __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_151] = [__v_118];
-                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_143] = [__v_118];
+                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17291,9 +16621,9 @@ fn aiur_fn_151(
                   5u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_18, __v_2]; 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 __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_127] = { let __args: [G; IN_127] = [__v_18]; 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 __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];
@@ -17346,17 +16676,17 @@ fn aiur_fn_151(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_136] = { let __args: [G; IN_136] = [__v_62, __v_109]; 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 __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_151] = { let __args: [G; IN_151] = [__v_8, __v_59, __v_2, __v_3, __v_4, __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 __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_151] = [__v_114];
-                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_143] = [__v_114];
+                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17371,9 +16701,9 @@ fn aiur_fn_151(
                   7u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_18, __v_2]; 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 __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_127] = { let __args: [G; IN_127] = [__v_18]; 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 __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];
@@ -17426,17 +16756,17 @@ fn aiur_fn_151(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_136] = { let __args: [G; IN_136] = [__v_62, __v_109]; 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 __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_151] = { let __args: [G; IN_151] = [__v_8, __v_59, __v_2, __v_3, __v_4, __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 __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_151] = [__v_114];
-                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_143] = [__v_114];
+                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17452,11 +16782,11 @@ fn aiur_fn_151(
                     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_151] = { let __args: [G; IN_151] = [__v_8, __v_59, __v_2, __v_62, __v_4, __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 __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_151] = [__v_64];
-                    record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_143] = [__v_64];
+                    record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -17475,15 +16805,15 @@ fn aiur_fn_151(
   })
 }
 
-const INPUT_SIZE_152: usize = 2;
-const IN_152: usize = 2;
-const OUT_152: usize = 2;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+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_152], ExecError> {
+) -> 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];
@@ -17499,12 +16829,12 @@ fn aiur_fn_152(
         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_152] = [__v_7, __v_10];
-        record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_152] = { let __args: [G; IN_152] = [__v_4, __v_1]; 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 __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 };
@@ -17514,19 +16844,19 @@ fn aiur_fn_152(
         let __v_10: G = __loaded[3];
         let __v_11: G = __loaded[4];
         let __v_12: G = __loaded[5];
-        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_754] = { let __args: [G; IN_754] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           4294967295u64 => {
-            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__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 __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_152] = [__v_17, __v_19];
-            record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_144] = [__v_17, __v_19];
+            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -17539,8 +16869,8 @@ fn aiur_fn_152(
             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_152] = [__v_17, __v_22];
-            record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_144] = [__v_17, __v_22];
+            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -17552,15 +16882,15 @@ fn aiur_fn_152(
   })
 }
 
-const INPUT_SIZE_153: usize = 1;
-const IN_153: usize = 1;
-const OUT_153: usize = 1;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+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_153], ExecError> {
+) -> 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 };
@@ -17616,18 +16946,18 @@ fn aiur_fn_153(
       _ => {
         match __v_1.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_2]; 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 __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_153] = [__v_50];
-                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_153] = [__v_0];
-                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_145] = [__v_0];
+                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -17637,8 +16967,8 @@ fn aiur_fn_153(
           },
           _ => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_153] = [__v_49];
-            record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_145] = [__v_49];
+            record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -17647,15 +16977,15 @@ fn aiur_fn_153(
   })
 }
 
-const INPUT_SIZE_154: usize = 4;
-const IN_154: usize = 4;
-const OUT_154: usize = 1;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+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_154], ExecError> {
+) -> 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];
@@ -17667,8 +16997,8 @@ fn aiur_fn_154(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_154] = [__v_3];
-        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_146] = [__v_3];
+        record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17681,15 +17011,15 @@ fn aiur_fn_154(
             let __v_10: G = (__v_5 - __v_0);
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_154] = [__v_8];
-                record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_154] = { let __args: [G; IN_154] = [__v_0, __v_6, __v_9, __v_3]; 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 __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_154] = [__v_11];
-                record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_146] = [__v_11];
+                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -17706,15 +17036,15 @@ fn aiur_fn_154(
   })
 }
 
-const INPUT_SIZE_155: usize = 4;
-const IN_155: usize = 4;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
+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_155], ExecError> {
+) -> 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];
@@ -17729,8 +17059,8 @@ fn aiur_fn_155(
         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_155] = [__v_9];
-        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_147] = [__v_9];
+        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17740,14 +17070,14 @@ fn aiur_fn_155(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_5]; 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 __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_154] = { let __args: [G; IN_154] = [__v_10, __v_2, __v_3, __v_8]; 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 __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];
   },
@@ -17779,11 +17109,11 @@ fn aiur_fn_155(
  };
             let __v_13: G = __mc_out___mc_2[0];
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_6, __v_9, __v_12, __v_13]; 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 __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_155] = [__v_16];
-            record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_147] = [__v_16];
+            record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -17798,15 +17128,15 @@ fn aiur_fn_155(
   })
 }
 
-const INPUT_SIZE_156: usize = 2;
-const IN_156: usize = 2;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
+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_156], ExecError> {
+) -> 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];
@@ -17816,23 +17146,23 @@ fn aiur_fn_156(
     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_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_4, __v_7]; 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 __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_156] = [__v_8];
-    record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_148] = [__v_8];
+    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_157: usize = 10;
-const IN_157: usize = 10;
-const OUT_157: usize = 6;
-fn aiur_fn_157(
-  inp: [G; IN_157],
+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_157], ExecError> {
+) -> 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];
@@ -17850,8 +17180,8 @@ fn aiur_fn_157(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_157] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 => {
@@ -17861,44 +17191,44 @@ fn aiur_fn_157(
         let __v_15: G = __loaded[2];
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_14]; 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 __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_157] = { let __args: [G; IN_157] = [__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[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 __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_157] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-                record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_154] = { let __args: [G; IN_154] = [__v_16, __v_2, __v_3, __v_11]; 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 __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_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_157] = { let __args: [G; IN_157] = [__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[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 __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_157] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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);
               },
             }
@@ -17915,15 +17245,15 @@ fn aiur_fn_157(
   })
 }
 
-const INPUT_SIZE_158: usize = 2;
-const IN_158: usize = 2;
-const OUT_158: usize = 6;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+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_158], ExecError> {
+) -> 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];
@@ -17935,28 +17265,28 @@ fn aiur_fn_158(
     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_157] = { let __args: [G; IN_157] = [__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[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 __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_158] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-    record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_159: usize = 2;
-const IN_159: usize = 2;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+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_159], ExecError> {
+) -> 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];
@@ -17969,8 +17299,8 @@ fn aiur_fn_159(
     let __v_7: G = __loaded[5];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_159] = [__v_0];
-        record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_151] = [__v_0];
+        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -17981,46 +17311,46 @@ fn aiur_fn_159(
         let __v_11: G = __loaded[3];
         let __v_12: G = __loaded[4];
         let __v_13: G = __loaded[5];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_159] = [__v_14];
-        record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_151] = [__v_14];
+        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_160: usize = 3;
-const IN_160: usize = 3;
-const OUT_160: usize = 1;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+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_160], ExecError> {
+) -> 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_161] = { let __args: [G; IN_161] = [__v_0, __v_1]; 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 __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_160] = [__v_3];
-    record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_152] = [__v_3];
+    record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_161: usize = 2;
-const IN_161: usize = 2;
-const OUT_161: usize = 1;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+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_161], ExecError> {
+) -> 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];
@@ -18077,20 +17407,20 @@ fn aiur_fn_161(
         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_161] = [__v_51];
-        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_134] = { let __args: [G; IN_134] = [__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[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 __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_161] = { let __args: [G; IN_161] = [__v_48, __v_51]; 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 __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_161] = [__v_53];
-        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_153] = [__v_53];
+        record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -18100,15 +17430,15 @@ fn aiur_fn_161(
   })
 }
 
-const INPUT_SIZE_162: usize = 3;
-const IN_162: usize = 3;
-const OUT_162: usize = 1;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+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_162], ExecError> {
+) -> 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];
@@ -18118,8 +17448,8 @@ fn aiur_fn_162(
         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_162] = [__v_5];
-        record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_154] = [__v_5];
+        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -18131,47 +17461,47 @@ fn aiur_fn_162(
         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_162] = { let __args: [G; IN_162] = [__v_8, __v_1, __v_10]; 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 __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_162] = [__v_12];
-        record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_154] = [__v_12];
+        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_163: usize = 3;
-const IN_163: usize = 3;
-const OUT_163: usize = 1;
-fn aiur_fn_163(
-  inp: [G; IN_163],
+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_163], ExecError> {
+) -> 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_164] = { let __args: [G; IN_164] = [__v_0, __v_1]; 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 __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_163] = [__v_3];
-    record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_155] = [__v_3];
+    record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_164: usize = 2;
-const IN_164: usize = 2;
-const OUT_164: usize = 1;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+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_164], ExecError> {
+) -> 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];
@@ -18228,8 +17558,8 @@ fn aiur_fn_164(
         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_164] = [__v_51];
-        record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_156] = [__v_51];
+        record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -18237,20 +17567,20 @@ fn aiur_fn_164(
           1u64 => {
             match __v_4.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_30]; 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_766] = { let __args: [G; IN_766] = [__v_30]; 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 __v_49: G = __r_arr[0];
                 let __v_50: G = G::from_u64(0);
-                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_49, __v_1, __v_50]; 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 __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_164] = { let __args: [G; IN_164] = [__v_48, __v_54]; 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 __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_776] = { let __args: [G; IN_776] = [__v_51, __v_55]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_51, __v_55]; 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 __v_56: G = __r_arr[0];
-                let __ret: [G; OUT_164] = [__v_56];
-                record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_156] = [__v_56];
+                record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -18258,19 +17588,19 @@ fn aiur_fn_164(
           0u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_48, __v_50]; 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 __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_164] = [__v_51];
-            record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_164] = { let __args: [G; IN_164] = [__v_48, __v_50]; 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 __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_164] = [__v_51];
-            record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_156] = [__v_51];
+            record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -18285,15 +17615,15 @@ fn aiur_fn_164(
   })
 }
 
-const INPUT_SIZE_165: usize = 1;
-const IN_165: usize = 1;
-const OUT_165: usize = 1;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+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_165], ExecError> {
+) -> 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 };
@@ -18347,23 +17677,23 @@ fn aiur_fn_165(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_165] = [__v_48];
-        record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_165] = [__v_48];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_165] = { let __args: [G; IN_165] = [__v_47]; 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 __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_165] = [__v_48];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_157] = [__v_48];
+            record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -18375,15 +17705,15 @@ fn aiur_fn_165(
   })
 }
 
-const INPUT_SIZE_166: usize = 19;
-const IN_166: usize = 19;
-const OUT_166: usize = 18;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+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_166], ExecError> {
+) -> 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];
@@ -18406,9 +17736,9 @@ fn aiur_fn_166(
     let __v_18: G = inp[18];
     match __v_0.as_canonical_u64() {
       11u64 => {
-        let __r_arr: [G; OUT_18] = { let __args: [G; IN_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[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_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_799] = { let __args: [G; IN_799] = [__v_18, __v_19]; 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_769] = { let __args: [G; IN_769] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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];
@@ -18435,7 +17765,7 @@ fn aiur_fn_166(
             let __v_39: G = __loaded[15];
             let __v_40: G = __loaded[16];
             let __v_41: G = __loaded[17];
-            let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__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[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 __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];
@@ -18454,8 +17784,8 @@ fn aiur_fn_166(
             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_166] = [__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[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
           _ => {
@@ -18464,23 +17794,23 @@ fn aiur_fn_166(
         }
       },
       _ => {
-        let __ret: [G; OUT_166] = [__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[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_167: usize = 20;
-const IN_167: usize = 20;
-const OUT_167: usize = 18;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+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_167], ExecError> {
+) -> 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];
@@ -18504,7 +17834,7 @@ fn aiur_fn_167(
     let __v_19: G = inp[19];
     match __v_18.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__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[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 __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];
@@ -18523,12 +17853,12 @@ fn aiur_fn_167(
         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_167] = [__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[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_166] = { let __args: [G; IN_166] = [__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[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 __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];
@@ -18570,7 +17900,7 @@ fn aiur_fn_167(
             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_167] = { let __args: [G; IN_167] = [__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[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 __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];
@@ -18589,13 +17919,13 @@ fn aiur_fn_167(
             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_167] = [__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[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_167] = [__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[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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);
           },
         }
@@ -18604,15 +17934,15 @@ fn aiur_fn_167(
   })
 }
 
-const INPUT_SIZE_168: usize = 19;
-const IN_168: usize = 19;
-const OUT_168: usize = 18;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+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_168], ExecError> {
+) -> 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];
@@ -18633,7 +17963,7 @@ fn aiur_fn_168(
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
     let __v_18: G = inp[18];
-    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__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[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 __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];
@@ -18673,7 +18003,7 @@ fn aiur_fn_168(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__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[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 __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];
@@ -18692,12 +18022,12 @@ fn aiur_fn_168(
         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_168] = [__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[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_166] = { let __args: [G; IN_166] = [__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[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 __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];
@@ -18716,23 +18046,23 @@ fn aiur_fn_168(
         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_168] = [__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[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_169: usize = 21;
-const IN_169: usize = 21;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+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_169], ExecError> {
+) -> 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];
@@ -18755,7 +18085,7 @@ fn aiur_fn_169(
     let __v_18: G = inp[18];
     let __v_19: G = inp[19];
     let __v_20: G = inp[20];
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__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[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 __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];
@@ -18795,7 +18125,7 @@ fn aiur_fn_169(
         let __v_54: G = __loaded[15];
         let __v_55: G = __loaded[16];
         let __v_56: G = __loaded[17];
-        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__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[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 __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];
@@ -18816,12 +18146,12 @@ fn aiur_fn_169(
         let __v_74: G = __r_arr[17];
         match __v_57.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_781] = { let __args: [G; IN_781] = [__v_19, __v_75]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_19, __v_75]; 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 __v_76: G = __r_arr[0];
-            let __ret: [G; OUT_169] = [__v_76];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_161] = [__v_76];
+            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -18858,8 +18188,8 @@ fn aiur_fn_169(
             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_169] = [__v_107];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_161] = [__v_107];
+            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -18898,23 +18228,23 @@ fn aiur_fn_169(
         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_169] = [__v_71];
-        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_161] = [__v_71];
+        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_170: usize = 48;
-const IN_170: usize = 48;
-const OUT_170: usize = 2;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+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_170], ExecError> {
+) -> 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];
@@ -18985,20 +18315,20 @@ fn aiur_fn_170(
         let __v_63: G = __loaded[15];
         let __v_64: G = __loaded[16];
         let __v_65: G = __loaded[17];
-        let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_18] = { let __args: [G; IN_18] = [__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[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_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_169] = { let __args: [G; IN_169] = [__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[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 __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_127] = { let __args: [G; IN_127] = [__v_73]; 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 __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];
@@ -19053,7 +18383,7 @@ fn aiur_fn_170(
               6u64 => {
                 match __v_75.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_83]; 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 __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];
@@ -19106,14 +18436,14 @@ fn aiur_fn_170(
                       _ => {
                         match __v_122.as_canonical_u64() {
                           8u64 => {
-                            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_83, __v_47]; 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 __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_18] = { let __args: [G; IN_18] = [__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[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_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_171] = { let __args: [G; IN_171] = [__v_123, __v_170, __v_171]; 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 __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_170] = [__v_172, __v_83];
-                            record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_162] = [__v_172, __v_83];
+                            record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -19136,37 +18466,37 @@ fn aiur_fn_170(
   })
 }
 
-const INPUT_SIZE_171: usize = 3;
-const IN_171: usize = 3;
-const OUT_171: usize = 1;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+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_171], ExecError> {
+) -> 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_172] = { let __args: [G; IN_172] = [__v_0, __v_1, __v_2, __v_3]; 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 __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_171] = [__v_4];
-    record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_163] = [__v_4];
+    record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_172: usize = 4;
-const IN_172: usize = 4;
-const OUT_172: usize = 1;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+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_172], ExecError> {
+) -> 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];
@@ -19225,12 +18555,12 @@ fn aiur_fn_172(
         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_172] = [__v_53];
-        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_134] = { let __args: [G; IN_134] = [__v_5, __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[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 __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));
@@ -19240,13 +18570,13 @@ fn aiur_fn_172(
               1u64 => {
                 match __v_6.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_32]; 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_766] = { let __args: [G; IN_766] = [__v_32]; 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 __v_54: G = __r_arr[0];
                     let __v_55: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_54, __v_1, __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 __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_172] = [__v_56];
-                    record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_164] = [__v_56];
+                    record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -19255,8 +18585,8 @@ fn aiur_fn_172(
                 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_172] = [__v_56];
-                record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_164] = [__v_56];
+                record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -19265,10 +18595,10 @@ fn aiur_fn_172(
             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_172] = { let __args: [G; IN_172] = [__v_50, __v_54, __v_2, __v_56]; 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 __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_172] = [__v_57];
-            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_164] = [__v_57];
+            record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -19283,15 +18613,15 @@ fn aiur_fn_172(
   })
 }
 
-const INPUT_SIZE_173: usize = 57;
-const IN_173: usize = 57;
-const OUT_173: usize = 1;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+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_173], ExecError> {
+) -> 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];
@@ -19354,34 +18684,34 @@ fn aiur_fn_173(
       1u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_27]; 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_766] = { let __args: [G; IN_766] = [__v_27]; 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 __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_50, __v_52]; 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 __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_162] = { let __args: [G; IN_162] = [__v_57, __v_59, __v_60]; 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 __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_174] = { let __args: [G; IN_174] = [__v_27, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; 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 __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_173] = [__v_67];
-            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_165] = { let __args: [G; IN_165] = [__v_50]; 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 __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_163] = { let __args: [G; IN_163] = [__v_50, __v_51, __v_58]; 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 __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);
@@ -19390,8 +18720,8 @@ fn aiur_fn_173(
             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_173] = [__v_66];
-            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_165] = [__v_66];
+            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -19402,7 +18732,7 @@ fn aiur_fn_173(
 }
  };
             let __v_58: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__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[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 __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);
@@ -19412,8 +18742,8 @@ fn aiur_fn_173(
             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_173] = [__v_67];
-            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_165] = [__v_67];
+            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -19431,8 +18761,8 @@ fn aiur_fn_173(
         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_173] = [__v_65];
-        record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_165] = [__v_65];
+        record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19442,15 +18772,15 @@ fn aiur_fn_173(
   })
 }
 
-const INPUT_SIZE_174: usize = 7;
-const IN_174: usize = 7;
-const OUT_174: usize = 1;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+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_174], ExecError> {
+) -> 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];
@@ -19501,8 +18831,8 @@ fn aiur_fn_174(
         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_174] = [__v_45];
-        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_166] = [__v_45];
+        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -19510,11 +18840,11 @@ fn aiur_fn_174(
         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_174] = { let __args: [G; IN_174] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __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_174] = [__v_48];
-        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_166] = [__v_48];
+        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19524,15 +18854,15 @@ fn aiur_fn_174(
   })
 }
 
-const INPUT_SIZE_175: usize = 13;
-const IN_175: usize = 13;
-const OUT_175: usize = 1;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+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_175], ExecError> {
+) -> 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];
@@ -19600,21 +18930,21 @@ fn aiur_fn_175(
         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_175] = [__v_62];
-        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_173] = { let __args: [G; IN_173] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[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 __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_175] = { let __args: [G; IN_175] = [__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[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 __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_776] = { let __args: [G; IN_776] = [__v_60, __v_63]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_60, __v_63]; 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 __v_64: G = __r_arr[0];
-        let __ret: [G; OUT_175] = [__v_64];
-        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_167] = [__v_64];
+        record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19624,15 +18954,15 @@ fn aiur_fn_175(
   })
 }
 
-const INPUT_SIZE_176: usize = 1;
-const IN_176: usize = 1;
-const OUT_176: usize = 2;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+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_176], ExecError> {
+) -> 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 };
@@ -19641,8 +18971,8 @@ fn aiur_fn_176(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_176] = [__v_2, __v_3];
-        record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_168] = [__v_2, __v_3];
+        record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19652,15 +18982,15 @@ fn aiur_fn_176(
   })
 }
 
-const INPUT_SIZE_177: usize = 7;
-const IN_177: usize = 7;
-const OUT_177: usize = 1;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+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_177], ExecError> {
+) -> 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];
@@ -19669,14 +18999,14 @@ fn aiur_fn_177(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2, __v_3]; 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 __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_139] = { let __args: [G; IN_139] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 __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];
@@ -19687,23 +19017,23 @@ fn aiur_fn_177(
     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_178] = { let __args: [G; IN_178] = [__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[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 __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_177] = [__v_23];
-    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_169] = [__v_23];
+    record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_178: usize = 9;
-const IN_178: usize = 9;
-const OUT_178: usize = 1;
-fn aiur_fn_178(
-  inp: [G; IN_178],
+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_178], ExecError> {
+) -> 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];
@@ -19723,8 +19053,8 @@ fn aiur_fn_178(
         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_178] = [__v_14];
-        record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_170] = [__v_14];
+        record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -19777,14 +19107,14 @@ fn aiur_fn_178(
         let __v_57: G = __loaded[45];
         let __v_58: G = __loaded[46];
         let __v_59: G = __loaded[47];
-        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_1]; 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 __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_145] = { let __args: [G; IN_145] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[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 __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 => {
@@ -19792,7 +19122,7 @@ fn aiur_fn_178(
     break '__mc_0 [__v_63];
   },
   _ => {
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_62, __v_8]; 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 __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];
   },
@@ -19801,10 +19131,10 @@ fn aiur_fn_178(
                 let __v_63: G = __mc_out___mc_0[0];
                 match __v_63.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_64];
-                    record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_170] = [__v_64];
+                    record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -19820,28 +19150,28 @@ fn aiur_fn_178(
 }
  };
                     let __v_64: G = __mc_out___mc_1[0];
-                    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_13]; 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 __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_137] = { let __args: [G; IN_137] = [__v_60, __v_3]; 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 __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_159] = { let __args: [G; IN_159] = [__v_60, __v_5]; 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 __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_152] = { let __args: [G; IN_152] = [__v_58, __v_3]; 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 __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_160] = { let __args: [G; IN_160] = [__v_13, __v_66, __v_70]; 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 __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_175] = { let __args: [G; IN_175] = [__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[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 __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_178] = { let __args: [G; IN_178] = [__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[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 __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_776] = { let __args: [G; IN_776] = [__v_73, __v_75]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_73, __v_75]; 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 __v_76: G = __r_arr[0];
-                    let __ret: [G; OUT_178] = [__v_76];
-                    record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_170] = [__v_76];
+                    record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -19850,35 +19180,35 @@ fn aiur_fn_178(
                 }
               },
               6u64 => {
-                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_62];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_62];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_62];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_62];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_152] = { let __args: [G; IN_152] = [__v_58, __v_3]; 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 __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);
@@ -19886,7 +19216,7 @@ fn aiur_fn_178(
                 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_131] = { let __args: [G; IN_131] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { 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 __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);
@@ -19894,15 +19224,15 @@ fn aiur_fn_178(
                 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_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_77];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_152] = { let __args: [G; IN_152] = [__v_58, __v_3]; 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 __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);
@@ -19914,15 +19244,15 @@ fn aiur_fn_178(
                 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_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_74];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_152] = { let __args: [G; IN_152] = [__v_58, __v_3]; 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 __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);
@@ -19934,18 +19264,18 @@ fn aiur_fn_178(
                 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_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_74];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_152] = { let __args: [G; IN_152] = [__v_58, __v_3]; 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 __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_170] = { let __args: [G; IN_170] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[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 __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);
@@ -19958,11 +19288,11 @@ fn aiur_fn_178(
                 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_178] = { let __args: [G; IN_178] = [__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[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 __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_178] = [__v_77];
-                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_170] = [__v_77];
+                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -19979,15 +19309,15 @@ fn aiur_fn_178(
   })
 }
 
-const INPUT_SIZE_179: usize = 10;
-const IN_179: usize = 10;
-const OUT_179: usize = 2;
-fn aiur_fn_179(
-  inp: [G; IN_179],
+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_179], ExecError> {
+) -> 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];
@@ -20000,7 +19330,7 @@ fn aiur_fn_179(
     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_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __v_11: G = __r_arr[0];
     match __v_11.as_canonical_u64() {
       1u64 => {
@@ -20010,16 +19340,16 @@ fn aiur_fn_179(
         let __v_14: G = __loaded[2];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_179] = [__v_2, __v_3];
-            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_179] = { let __args: [G; IN_179] = [__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[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 __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_179] = [__v_15, __v_16];
-            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_171] = [__v_15, __v_16];
+            record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -20090,16 +19420,16 @@ fn aiur_fn_179(
             let __v_55: G = __loaded[2];
             match __v_53.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_179] = [__v_2, __v_3];
-                record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_179] = { let __args: [G; IN_179] = [__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[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 __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_179] = [__v_56, __v_57];
-                record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_171] = [__v_56, __v_57];
+                record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -20111,14 +19441,14 @@ fn aiur_fn_179(
             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_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_127] = { let __args: [G; IN_127] = [__v_0]; 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 __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];
@@ -20172,7 +19502,7 @@ fn aiur_fn_179(
             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_133] = { let __args: [G; IN_133] = [__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[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 __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);
@@ -20207,16 +19537,16 @@ fn aiur_fn_179(
                 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_130] = { let __args: [G; IN_130] = [__v_113, __v_146]; 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 __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_776] = { let __args: [G; IN_776] = [__v_108, __v_150]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_108, __v_150]; 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 __v_151: G = __r_arr[0];
-                    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_151, __v_1]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_151, __v_1]; 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 __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];
@@ -20224,16 +19554,16 @@ fn aiur_fn_179(
                     let __v_155: G = __loaded[2];
                     match __v_153.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_179] = [__v_54, __v_112];
-                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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_179] = { let __args: [G; IN_179] = [__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[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 __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_179] = [__v_156, __v_157];
-                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_171] = [__v_156, __v_157];
+                        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -20247,9 +19577,9 @@ fn aiur_fn_179(
                     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_776] = { let __args: [G; IN_776] = [__v_108, __v_152]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_108, __v_152]; 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 __v_153: G = __r_arr[0];
-                    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_153, __v_1]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_153, __v_1]; 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 __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];
@@ -20257,16 +19587,16 @@ fn aiur_fn_179(
                     let __v_157: G = __loaded[2];
                     match __v_155.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_179] = [__v_54, __v_112];
-                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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_179] = { let __args: [G; IN_179] = [__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[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 __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_179] = [__v_158, __v_159];
-                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_171] = [__v_158, __v_159];
+                        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -20287,119 +19617,15 @@ fn aiur_fn_179(
   })
 }
 
-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_180], 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_179] = { let __args: [G; IN_179] = [__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[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 __v_13: G = __r_arr[1];
-    let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_12, __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 __v_16: G = __r_arr[1];
-    let __v_17: G = __r_arr[2];
-    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_16]; 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_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];
-    let __v_24: G = { let __values: [G; 6] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; 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_25: G = G::from_u64(0);
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_13, __v_12, __v_24, __v_25]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_13, __v_26]; 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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_12, __v_13]; 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_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 = { let __values: [G; 6] = [__v_28, __v_29, __v_30, __v_31, __v_32, __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 __v_35: G = G::from_u64(0);
-    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; 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_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_36]; 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_37: G = __r_arr[0];
-    let __ret: [G; OUT_180] = [__v_37];
-    record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_181: usize = 5;
-const IN_181: usize = 5;
-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 = (__v_0 - __v_1);
-    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; 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_181] = [__v_8];
-        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_2, __v_3, __v_4]; 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_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_0 + __v_8);
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_9, __v_1, __v_2, __v_3, __v_4]; 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_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_181] = [__v_11];
-        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 = 1;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+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_182], ExecError> {
+) -> 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 };
@@ -20456,32 +19682,32 @@ fn aiur_fn_182(
         match __v_1.as_canonical_u64() {
           6u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_182] = [__v_49];
-            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_182] = [__v_49];
-            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_182] = [__v_49];
-            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_182] = [__v_49];
-            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_182] = [__v_49];
-            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_172] = [__v_49];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -20490,253 +19716,15 @@ fn aiur_fn_182(
   })
 }
 
-const INPUT_SIZE_183: usize = 4;
-const IN_183: usize = 4;
-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 __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 __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 __ret: [G; OUT_183] = [__v_7, __v_40];
-        record.function_queries[183].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 __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_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 = (__v_11 - __v_0);
-                let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !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_15: G = __r_arr[0];
-                let __v_16: G = (__v_14 * __v_15);
-                match __v_16.as_canonical_u64() {
-                  1u64 => {
-                    let __v_17: G = G::from_u64(1);
-                    let __ret: [G; OUT_183] = [__v_17, __v_5];
-                    record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_6, __v_9, __v_12]; 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_17: G = __r_arr[0];
-                    let __v_18: G = __r_arr[1];
-                    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_10.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_184: usize = 3;
-const IN_184: usize = 3;
-const OUT_184: usize = 1;
-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 = 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 __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 = { let __values: [G; 32] = [__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]; 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_184] = [__v_38];
-        record.function_queries[184].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_7 - __v_0);
-            match __v_9.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_184] = [__v_4];
-                record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_5, __v_8]; 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_184] = [__v_10];
-                record.function_queries[184].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_185: usize = 4;
-const IN_185: usize = 4;
-const OUT_185: usize = 1;
-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 __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_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __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_4.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_185] = [__v_5];
-        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_3]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_185] = [__v_6];
-        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_186: usize = 10;
-const IN_186: usize = 10;
-const OUT_186: usize = 6;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+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_186], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20754,8 +19742,8 @@ fn aiur_fn_186(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_186] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 => {
@@ -20771,39 +19759,39 @@ fn aiur_fn_186(
             let __v_18: G = __loaded[2];
             match __v_16.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_14]; 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 __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_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_186] = { let __args: [G; IN_186] = [__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[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 __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_186] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-                    record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_186] = { let __args: [G; IN_186] = [__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[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 __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_186] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-                    record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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);
                   },
                 }
@@ -20825,15 +19813,15 @@ fn aiur_fn_186(
   })
 }
 
-const INPUT_SIZE_187: usize = 3;
-const IN_187: usize = 3;
-const OUT_187: usize = 6;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+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_187], ExecError> {
+) -> 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];
@@ -20841,7 +19829,7 @@ fn aiur_fn_187(
     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_186] = { let __args: [G; IN_186] = [__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[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 __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];
@@ -20849,28 +19837,28 @@ fn aiur_fn_187(
     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_186] = { let __args: [G; IN_186] = [__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[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 __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_187] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-    record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_188: usize = 7;
-const IN_188: usize = 7;
-const OUT_188: usize = 6;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+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_188], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20886,27 +19874,27 @@ fn aiur_fn_188(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_188] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_188] = { let __args: [G; IN_188] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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_188] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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);
       },
       _ => {
@@ -20916,15 +19904,15 @@ fn aiur_fn_188(
   })
 }
 
-const INPUT_SIZE_189: usize = 9;
-const IN_189: usize = 9;
-const OUT_189: usize = 1;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+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_189], ExecError> {
+) -> 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];
@@ -20941,36 +19929,36 @@ fn aiur_fn_189(
         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_189] = [__v_12];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __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_189] = { let __args: [G; IN_189] = [__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[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_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_189] = [__v_15];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_176] = [__v_15];
+        record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_190: usize = 3;
-const IN_190: usize = 3;
-const OUT_190: usize = 1;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+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_190], ExecError> {
+) -> Result<[G; OUT_177], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20984,8 +19972,8 @@ fn aiur_fn_190(
         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_190] = [__v_8];
-        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_177] = [__v_8];
+        record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21050,9 +20038,9 @@ fn aiur_fn_190(
                   6u64 => {
                     match __v_7.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_15, __v_2]; 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 __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_127] = { let __args: [G; IN_127] = [__v_15]; 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 __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];
@@ -21105,33 +20093,33 @@ fn aiur_fn_190(
                           _ => {
                             match __v_58.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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[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_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_136] = { let __args: [G; IN_136] = [__v_59, __v_106]; 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 __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_18] = { let __args: [G; IN_18] = [__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[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_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_191] = { let __args: [G; IN_191] = [__v_59, __v_111]; 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 __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_193] = { let __args: [G; IN_193] = [__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[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 __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_190] = { let __args: [G; IN_190] = [__v_5, __v_56, __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 __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_790] = { let __args: [G; IN_790] = [__v_114, __v_115]; 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 __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_114, __v_115]; 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_116: G = __r_arr[0];
-                                let __ret: [G; OUT_190] = [__v_116];
-                                record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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_190] = { let __args: [G; IN_190] = [__v_5, __v_56, __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 __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_190] = [__v_106];
-                                record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_177] = [__v_106];
+                                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -21141,10 +20129,10 @@ fn aiur_fn_190(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_5, __v_56, __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 __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_190] = [__v_57];
-                    record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_177] = [__v_57];
+                    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -21163,36 +20151,36 @@ fn aiur_fn_190(
   })
 }
 
-const INPUT_SIZE_191: usize = 2;
-const IN_191: usize = 2;
-const OUT_191: usize = 1;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+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_191], ExecError> {
+) -> 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_192] = { let __args: [G; IN_192] = [__v_0, __v_1, __v_2]; 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 __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_191] = [__v_3];
-    record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_178] = [__v_3];
+    record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 3;
-const IN_192: usize = 3;
-const OUT_192: usize = 1;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+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_192], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21248,8 +20236,8 @@ fn aiur_fn_192(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_50: G = G::from_u64(0);
-        let __ret: [G; OUT_192] = [__v_50];
-        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_179] = [__v_50];
+        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21260,18 +20248,18 @@ fn aiur_fn_192(
               1u64 => {
                 match __v_5.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_31]; 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_766] = { let __args: [G; IN_766] = [__v_31]; 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 __v_51: G = __r_arr[0];
-                    let __ret: [G; OUT_192] = [__v_51];
-                    record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_192] = [__v_51];
-                record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_179] = [__v_51];
+                record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -21279,10 +20267,10 @@ fn aiur_fn_192(
           _ => {
             let __v_51: G = G::from_u64(1);
             let __v_52: G = (__v_2 + __v_51);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_49, __v_1, __v_52]; 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 __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_192] = [__v_53];
-            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_179] = [__v_53];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -21294,15 +20282,15 @@ fn aiur_fn_192(
   })
 }
 
-const INPUT_SIZE_193: usize = 12;
-const IN_193: usize = 12;
-const OUT_193: usize = 1;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+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_193], ExecError> {
+) -> Result<[G; OUT_180], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21322,37 +20310,37 @@ fn aiur_fn_193(
         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_193] = [__v_15];
-        record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_194] = { let __args: [G; IN_194] = [__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[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 __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_193] = { let __args: [G; IN_193] = [__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[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 __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_193] = [__v_19];
-        record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_180] = [__v_19];
+        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_194: usize = 10;
-const IN_194: usize = 10;
-const OUT_194: usize = 1;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+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_194], ExecError> {
+) -> Result<[G; OUT_181], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21385,25 +20373,25 @@ fn aiur_fn_194(
     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_73] = { let __args: [G; IN_73] = [__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[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_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_23] = { let __args: [G; IN_23] = [__v_31]; 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_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_194] = [__v_32];
-    record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_181] = [__v_32];
+    record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_195: usize = 1;
-const IN_195: usize = 1;
-const OUT_195: usize = 2;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+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_195], ExecError> {
+) -> 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);
@@ -21417,27 +20405,27 @@ fn aiur_fn_195(
     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_179] = { let __args: [G; IN_179] = [__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[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 __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_197] = { let __args: [G; IN_197] = [__v_12, __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 __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_195] = [__v_14, __v_15];
-    record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_196: usize = 1;
-const IN_196: usize = 1;
-const OUT_196: usize = 2;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+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_196], ExecError> {
+) -> 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 };
@@ -21446,11 +20434,11 @@ fn aiur_fn_196(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        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 __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_196] = [__v_4, __v_5];
-        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_183] = [__v_4, __v_5];
+        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21462,14 +20450,14 @@ fn aiur_fn_196(
         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_179] = { let __args: [G; IN_179] = [__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[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 __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_197] = { let __args: [G; IN_197] = [__v_12, __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 __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_196] = [__v_14, __v_15];
-        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_183] = [__v_14, __v_15];
+        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -21479,24 +20467,24 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-const OUT_197: usize = 2;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+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_197], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_0, __v_2]; 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 __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_141] = { let __args: [G; IN_141] = [__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 __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];
@@ -21505,11 +20493,11 @@ fn aiur_fn_197(
     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_150] = { let __args: [G; IN_150] = [__v_1, __v_0, __v_12, __v_13]; 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 __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_156] = { let __args: [G; IN_156] = [__v_1, __v_14]; 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 __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_158] = { let __args: [G; IN_158] = [__v_0, __v_1]; 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 __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];
@@ -21518,20 +20506,20 @@ fn aiur_fn_197(
     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_177] = { let __args: [G; IN_177] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; 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 __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_126] = { let __args: [G; IN_126] = [__v_24]; 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 __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_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __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 __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_190] = { let __args: [G; IN_190] = [__v_1, __v_0, __v_12]; 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_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_188] = { let __args: [G; IN_188] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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 __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];
@@ -21572,32 +20560,32 @@ fn aiur_fn_197(
     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_189] = { let __args: [G; IN_189] = [__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[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_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_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 __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_776] = { let __args: [G; IN_776] = [__v_25, __v_74]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_25, __v_74]; 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 __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_73, __v_75]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_73, __v_75]; 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 __v_77: G = __r_arr[0];
-    let __ret: [G; OUT_197] = [__v_76, __v_77];
-    record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_198: usize = 0;
-const IN_198: usize = 0;
-const OUT_198: usize = 2;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+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_198], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    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 __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);
@@ -21610,232 +20598,232 @@ fn aiur_fn_198(
     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_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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_201] = { let __args: [G; IN_201] = [__v_11, __v_12]; 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 __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_198] = [__v_13, __v_0];
-    record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_199: usize = 0;
-const IN_199: usize = 0;
-const OUT_199: usize = 1;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+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_199], ExecError> {
+) -> 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_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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = []; 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_1: G = __r_arr[0];
     let __v_2: 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = []; 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_3: G = __r_arr[0];
     let __v_4: 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 __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = []; 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 __v_6: 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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = []; 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_7: G = __r_arr[0];
     let __v_8: 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = []; 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 __v_10: 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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = []; 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_11: G = __r_arr[0];
     let __v_12: 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 __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_13: G = __r_arr[0];
     let __v_14: 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 __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_15: G = __r_arr[0];
     let __v_16: 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 __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_17: G = __r_arr[0];
     let __v_18: 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 __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_19: G = __r_arr[0];
     let __v_20: 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 __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_21: G = __r_arr[0];
     let __v_22: 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 __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_23: G = __r_arr[0];
     let __v_24: 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 __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_25: G = __r_arr[0];
     let __v_26: 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 __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_27: G = __r_arr[0];
     let __v_28: 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 __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_29: G = __r_arr[0];
     let __v_30: 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 __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_31: G = __r_arr[0];
     let __v_32: 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 __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_33: G = __r_arr[0];
     let __v_34: 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 __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_35: G = __r_arr[0];
     let __v_36: 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 __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_37: G = __r_arr[0];
     let __v_38: 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 __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_39: G = __r_arr[0];
     let __v_40: 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 __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_41: G = __r_arr[0];
     let __v_42: 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 __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_43: G = __r_arr[0];
     let __v_44: 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 __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_45: G = __r_arr[0];
     let __v_46: 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 __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_47: G = __r_arr[0];
     let __v_48: 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 __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_49: G = __r_arr[0];
     let __v_50: 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 __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_51: G = __r_arr[0];
     let __v_52: 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 __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_53: G = __r_arr[0];
     let __v_54: 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 __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_55: G = __r_arr[0];
     let __v_56: 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 __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_57: G = __r_arr[0];
     let __v_58: 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 __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_59: G = __r_arr[0];
     let __v_60: 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 __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_61: G = __r_arr[0];
     let __v_62: 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 __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_63: G = __r_arr[0];
     let __v_64: 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 __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_65: G = __r_arr[0];
     let __v_66: 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 __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_67: G = __r_arr[0];
     let __v_68: 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 __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_69: G = __r_arr[0];
     let __v_70: 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 __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_71: G = __r_arr[0];
     let __v_72: 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 __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_73: G = __r_arr[0];
     let __v_74: 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 __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_75: G = __r_arr[0];
     let __v_76: 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 __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_77: G = __r_arr[0];
     let __v_78: 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 __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_79: G = __r_arr[0];
     let __v_80: 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 __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_81: G = __r_arr[0];
     let __v_82: 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 __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_83: G = __r_arr[0];
     let __v_84: 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 __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_85: G = __r_arr[0];
     let __v_86: 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 __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_87: G = __r_arr[0];
     let __v_88: 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 __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_89: G = __r_arr[0];
     let __v_90: 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 __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_91: G = __r_arr[0];
     let __v_92: 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 __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_93: G = __r_arr[0];
     let __v_94: 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 __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_95: G = __r_arr[0];
     let __v_96: 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 __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_97: G = __r_arr[0];
     let __v_98: 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 __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_99: G = __r_arr[0];
     let __v_100: 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 __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_101: G = __r_arr[0];
     let __v_102: 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 __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_103: G = __r_arr[0];
     let __v_104: 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 __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_105: G = __r_arr[0];
     let __v_106: 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 __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_107: G = __r_arr[0];
     let __v_108: 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 __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_109: G = __r_arr[0];
     let __v_110: 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 __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_111: G = __r_arr[0];
     let __v_112: 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 __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_113: G = __r_arr[0];
     let __v_114: 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 __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_115: G = __r_arr[0];
     let __v_116: G = G::from_u64(0);
-    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 __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_117: G = __r_arr[0];
     let __v_118: G = G::from_u64(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 __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_119: G = __r_arr[0];
     let __v_120: 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 __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_121: G = __r_arr[0];
     let __v_122: 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 __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_123: G = __r_arr[0];
     let __v_124: 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 __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_125: G = __r_arr[0];
     let __v_126: 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 __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_127: G = __r_arr[0];
     let __v_128: G = G::from_u64(0);
-    let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; 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 __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_129: G = __r_arr[0];
     let __v_130: G = G::from_u64(0);
-    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; 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 __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_131: G = __r_arr[0];
     let __v_132: G = G::from_u64(0);
-    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; 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 __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_133: G = __r_arr[0];
     let __v_134: G = G::from_u64(0);
-    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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 __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_135: G = __r_arr[0];
     let __v_136: G = G::from_u64(0);
-    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = []; 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 __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_137: G = __r_arr[0];
     let __v_138: G = G::from_u64(1);
     let __v_139: G = G::from_u64(1);
@@ -21909,21 +20897,21 @@ fn aiur_fn_199(
     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_199] = [__v_209];
-    record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_186] = [__v_209];
+    record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_200: usize = 1;
-const IN_200: usize = 1;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+const INPUT_SIZE_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_200], ExecError> {
+) -> 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 };
@@ -21933,17 +20921,17 @@ fn aiur_fn_200(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_200] = [__v_4];
-        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_200] = { let __args: [G; IN_200] = [__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 __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_200] = [__v_6];
-        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_187] = [__v_6];
+        record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -21953,15 +20941,15 @@ fn aiur_fn_200(
   })
 }
 
-const INPUT_SIZE_201: usize = 2;
-const IN_201: usize = 2;
-const OUT_201: usize = 1;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+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_201], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21970,34 +20958,34 @@ fn aiur_fn_201(
         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_201] = [__v_4];
-        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_201] = { let __args: [G; IN_201] = [__v_0, __v_4]; 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 __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_201] = [__v_6];
-        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_188] = [__v_6];
+        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_202: usize = 1;
-const IN_202: usize = 1;
-const OUT_202: usize = 2;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+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_202], ExecError> {
+) -> 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 };
@@ -22007,36 +20995,36 @@ fn aiur_fn_202(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__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 __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_773] = { let __args: [G; IN_773] = [__v_6, __v_3]; 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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_6, __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_202] = [__v_5, __v_7];
-        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_202] = [__v_0, __v_7];
-        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_203: usize = 1;
-const IN_203: usize = 1;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+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_203], ExecError> {
+) -> 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 };
@@ -22046,57 +21034,57 @@ fn aiur_fn_203(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_203] = [__v_4];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_203] = [__v_4];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_203] = [__v_4];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_203] = { let __args: [G; IN_203] = [__v_2]; 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 __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_203] = { let __args: [G; IN_203] = [__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 __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_203] = [__v_6];
-                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_203] = [__v_6];
-                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_203] = [__v_6];
-            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_203] = { let __args: [G; IN_203] = [__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 __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_203] = [__v_4];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_190] = [__v_4];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -22106,15 +21094,15 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 2;
-const IN_204: usize = 2;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+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_204], ExecError> {
+) -> 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];
@@ -22131,14 +21119,14 @@ fn aiur_fn_204(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_204] = [__v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_204] = [__v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_191] = [__v_8];
+            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22150,16 +21138,16 @@ fn aiur_fn_204(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_6]; 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 __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_204] = [__v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_204] = [__v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_191] = [__v_8];
+            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22171,19 +21159,19 @@ fn aiur_fn_204(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_6]; 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 __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_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; 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 __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_204] = [__v_10];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_204] = [__v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_191] = [__v_8];
+            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22195,19 +21183,19 @@ fn aiur_fn_204(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_6]; 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 __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_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; 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 __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_204] = [__v_10];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_204] = [__v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_191] = [__v_8];
+            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22221,14 +21209,14 @@ fn aiur_fn_204(
           4u64 => {
             let __v_8: G = (__v_3 - __v_6);
             let __v_9: G = G::from_bool((__v_8 == G::ZERO));
-            let __ret: [G; OUT_204] = [__v_9];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_204] = [__v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_191] = [__v_8];
+            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -22240,15 +21228,15 @@ fn aiur_fn_204(
   })
 }
 
-const INPUT_SIZE_205: usize = 2;
-const IN_205: usize = 2;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+const INPUT_SIZE_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_205], ExecError> {
+) -> Result<[G; OUT_192], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22265,14 +21253,14 @@ fn aiur_fn_205(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_205] = [__v_8];
-            record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_205] = [__v_8];
-            record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_192] = [__v_8];
+            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22288,8 +21276,8 @@ fn aiur_fn_205(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_205] = [__v_8];
-            record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_192] = [__v_8];
+            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22297,8 +21285,8 @@ fn aiur_fn_205(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_205] = [__v_9];
-                record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_192] = [__v_9];
+                record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -22306,15 +21294,15 @@ fn aiur_fn_205(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_205] = [__v_10];
-                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_205] = { let __args: [G; IN_205] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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_205] = [__v_10];
-                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_192] = [__v_10];
+                    record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -22339,15 +21327,15 @@ fn aiur_fn_205(
   })
 }
 
-const INPUT_SIZE_206: usize = 2;
-const IN_206: usize = 2;
-const OUT_206: usize = 1;
-fn aiur_fn_206(
-  inp: [G; IN_206],
+const INPUT_SIZE_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_206], ExecError> {
+) -> Result<[G; OUT_193], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22358,8 +21346,8 @@ fn aiur_fn_206(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_206] = [__v_5];
-        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_193] = [__v_5];
+        record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22370,8 +21358,8 @@ fn aiur_fn_206(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_206] = [__v_8];
-            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_193] = [__v_8];
+            record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22379,25 +21367,25 @@ fn aiur_fn_206(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_206] = [__v_9];
-                record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_206] = { let __args: [G; IN_206] = [__v_0, __v_7]; 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 __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_206] = [__v_10];
-                    record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_206] = { let __args: [G; IN_206] = [__v_4, __v_7]; 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 __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_206] = [__v_10];
-                    record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_193] = [__v_10];
+                    record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -22422,15 +21410,15 @@ fn aiur_fn_206(
   })
 }
 
-const INPUT_SIZE_207: usize = 2;
-const IN_207: usize = 2;
-const OUT_207: usize = 1;
-fn aiur_fn_207(
-  inp: [G; IN_207],
+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_207], ExecError> {
+) -> Result<[G; OUT_194], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22447,14 +21435,14 @@ fn aiur_fn_207(
         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));
+            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_207] = [__v_8];
-            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_194] = [__v_8];
+            record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22470,15 +21458,15 @@ fn aiur_fn_207(
         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));
+            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_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 __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_207] = [__v_8];
-            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_194] = [__v_8];
+            record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22493,15 +21481,15 @@ fn aiur_fn_207(
   })
 }
 
-const INPUT_SIZE_208: usize = 2;
-const IN_208: usize = 2;
-const OUT_208: usize = 2;
-fn aiur_fn_208(
-  inp: [G; IN_208],
+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_208], ExecError> {
+) -> Result<[G; OUT_195], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22517,8 +21505,8 @@ fn aiur_fn_208(
         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_208] = [__v_5, __v_10];
-        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_195] = [__v_5, __v_10];
+        record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22528,8 +21516,8 @@ fn aiur_fn_208(
             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_208] = [__v_6, __v_8];
-            record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_195] = [__v_6, __v_8];
+            record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22537,18 +21525,18 @@ fn aiur_fn_208(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_208] = [__v_7, __v_1];
-                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_208] = { let __args: [G; IN_208] = [__v_0, __v_4]; 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 __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_208] = [__v_7, __v_10];
-                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_195] = [__v_7, __v_10];
+                record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -22568,15 +21556,15 @@ fn aiur_fn_208(
   })
 }
 
-const INPUT_SIZE_209: usize = 3;
-const IN_209: usize = 3;
-const OUT_209: usize = 1;
-fn aiur_fn_209(
-  inp: [G; IN_209],
+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_209], ExecError> {
+) -> Result<[G; OUT_196], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22593,8 +21581,8 @@ fn aiur_fn_209(
         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_209] = [__v_11];
-        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_196] = [__v_11];
+        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22609,8 +21597,8 @@ fn aiur_fn_209(
                 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_209] = [__v_11];
-                record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_196] = [__v_11];
+                record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -22618,11 +21606,11 @@ fn aiur_fn_209(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_1, __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 __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_209] = [__v_12];
-                    record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_196] = [__v_12];
+                    record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -22632,13 +21620,13 @@ fn aiur_fn_209(
                         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_209] = [__v_13];
-                        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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_209] = [__v_0];
-                        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_196] = [__v_0];
+                        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -22665,15 +21653,15 @@ fn aiur_fn_209(
   })
 }
 
-const INPUT_SIZE_210: usize = 2;
-const IN_210: usize = 2;
-const OUT_210: usize = 1;
-fn aiur_fn_210(
-  inp: [G; IN_210],
+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_210], ExecError> {
+) -> 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];
@@ -22690,14 +21678,14 @@ fn aiur_fn_210(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_210] = [__v_8];
-            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_210] = [__v_8];
-            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_197] = [__v_8];
+            record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22713,8 +21701,8 @@ fn aiur_fn_210(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_210] = [__v_8];
-            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_197] = [__v_8];
+            record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22734,24 +21722,24 @@ fn aiur_fn_210(
                         let __v_13: G = (__v_9 - __v_11);
                         match __v_13.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __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 __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_210] = [__v_14];
-                            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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_210] = [__v_14];
-                            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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_210] = [__v_13];
-                        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_197] = [__v_13];
+                        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -22772,15 +21760,15 @@ fn aiur_fn_210(
   })
 }
 
-const INPUT_SIZE_211: usize = 1;
-const IN_211: usize = 1;
-const OUT_211: usize = 1;
-fn aiur_fn_211(
-  inp: [G; IN_211],
+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_211], ExecError> {
+) -> 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 };
@@ -22790,8 +21778,8 @@ fn aiur_fn_211(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_211] = [__v_4];
-        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_198] = [__v_4];
+        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22800,18 +21788,18 @@ fn aiur_fn_211(
         let __v_5: G = __loaded[1];
         match __v_4.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__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 __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_211] = [__v_5];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_211] = [__v_6];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_198] = [__v_6];
+                record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -22828,15 +21816,15 @@ fn aiur_fn_211(
   })
 }
 
-const INPUT_SIZE_212: usize = 2;
-const IN_212: usize = 2;
-const OUT_212: usize = 1;
-fn aiur_fn_212(
-  inp: [G; IN_212],
+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_212], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22846,8 +21834,8 @@ fn aiur_fn_212(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_212] = [__v_0];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_199] = [__v_0];
+        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22857,8 +21845,8 @@ fn aiur_fn_212(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_212] = [__v_0];
-            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_199] = [__v_0];
+            record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22876,21 +21864,21 @@ fn aiur_fn_212(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(0);
-                        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 __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_212] = [__v_15];
-                        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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_212] = { let __args: [G; IN_212] = [__v_0, __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 __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_212] = [__v_14];
-                            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_199] = [__v_14];
+                            record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -22898,18 +21886,18 @@ fn aiur_fn_212(
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4, __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 __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_212] = [__v_17];
-                                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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_212] = { let __args: [G; IN_212] = [__v_4, __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 __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_212] = [__v_15];
-                                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_199] = [__v_15];
+                                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -22943,23 +21931,23 @@ fn aiur_fn_212(
   })
 }
 
-const INPUT_SIZE_213: usize = 3;
-const IN_213: usize = 3;
-const OUT_213: usize = 1;
-fn aiur_fn_213(
-  inp: [G; IN_213],
+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_213], ExecError> {
+) -> 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_213] = [__v_0];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_200] = [__v_0];
+        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -22969,15 +21957,15 @@ fn aiur_fn_213(
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2]; 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 __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_213] = [__v_6];
-            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_213] = [__v_0];
-            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_200] = [__v_0];
+            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22986,25 +21974,25 @@ fn aiur_fn_213(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2]; 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 __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_213] = [__v_3];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_200] = [__v_3];
+        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_214: usize = 3;
-const IN_214: usize = 3;
-const OUT_214: usize = 1;
-fn aiur_fn_214(
-  inp: [G; IN_214],
+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_214], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23024,8 +22012,8 @@ fn aiur_fn_214(
         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_214] = [__v_14];
-        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_201] = [__v_14];
+        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23035,7 +22023,7 @@ fn aiur_fn_214(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_6]; 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 __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 => {
@@ -23045,13 +22033,13 @@ fn aiur_fn_214(
                     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_214] = [__v_13];
-                    record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_214] = [__v_0];
-                    record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_201] = [__v_0];
+                    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23066,17 +22054,17 @@ fn aiur_fn_214(
                 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_214] = [__v_15];
-                record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_214] = { let __args: [G; IN_214] = [__v_5, __v_1, __v_2]; 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 __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_214] = [__v_12];
-                record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_201] = [__v_12];
+                record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23090,15 +22078,15 @@ fn aiur_fn_214(
   })
 }
 
-const INPUT_SIZE_215: usize = 4;
-const IN_215: usize = 4;
-const OUT_215: usize = 1;
-fn aiur_fn_215(
-  inp: [G; IN_215],
+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_215], ExecError> {
+) -> 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];
@@ -23123,8 +22111,8 @@ fn aiur_fn_215(
         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_215] = [__v_19];
-        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_202] = [__v_19];
+        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23134,17 +22122,17 @@ fn aiur_fn_215(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_7]; 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 __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_209] = { let __args: [G; IN_209] = [__v_9, __v_2, __v_3]; 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 __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_215] = [__v_14];
-                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_202] = [__v_14];
+                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -23158,17 +22146,17 @@ fn aiur_fn_215(
                 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_215] = [__v_20];
-                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_215] = { let __args: [G; IN_215] = [__v_6, __v_1, __v_2, __v_3]; 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 __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_215] = [__v_13];
-                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_202] = [__v_13];
+                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23182,15 +22170,15 @@ fn aiur_fn_215(
   })
 }
 
-const INPUT_SIZE_216: usize = 4;
-const IN_216: usize = 4;
-const OUT_216: usize = 1;
-fn aiur_fn_216(
-  inp: [G; IN_216],
+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_216], ExecError> {
+) -> Result<[G; OUT_203], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23202,63 +22190,63 @@ fn aiur_fn_216(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __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 __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_216] = [__v_7];
-        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_216] = { let __args: [G; IN_216] = [__v_5, __v_1, __v_8, __v_3]; 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 __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_216] = [__v_9];
-        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_216] = { let __args: [G; IN_216] = [__v_5, __v_1, __v_2, __v_3]; 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 __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_216] = { let __args: [G; IN_216] = [__v_6, __v_1, __v_2, __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 __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_216] = [__v_8];
-        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_217] = { let __args: [G; IN_217] = [__v_5, __v_6, __v_1, __v_2, __v_3]; 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 __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_216] = [__v_7];
-        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_208] = { let __args: [G; IN_208] = [__v_5, __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 __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_213] = { let __args: [G; IN_213] = [__v_3, __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 __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_215] = { let __args: [G; IN_215] = [__v_9, __v_8, __v_5, __v_2]; 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 __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_216] = [__v_10];
-            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_216] = [__v_3];
-                record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_215] = { let __args: [G; IN_215] = [__v_3, __v_1, __v_5, __v_2]; 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 __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_216] = [__v_9];
-                record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_203] = [__v_9];
+                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23275,15 +22263,15 @@ fn aiur_fn_216(
   })
 }
 
-const INPUT_SIZE_217: usize = 5;
-const IN_217: usize = 5;
-const OUT_217: usize = 1;
-fn aiur_fn_217(
-  inp: [G; IN_217],
+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_217], ExecError> {
+) -> Result<[G; OUT_204], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23296,55 +22284,55 @@ fn aiur_fn_217(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_4, __v_2, __v_3]; 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 __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_217] = [__v_8];
-        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_216] = { let __args: [G; IN_216] = [__v_0, __v_2, __v_3, __v_4]; 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 __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_216] = { let __args: [G; IN_216] = [__v_6, __v_2, __v_9, __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 __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_217] = [__v_11];
-        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_217] = { let __args: [G; IN_217] = [__v_0, __v_6, __v_2, __v_3, __v_4]; 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 __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_217] = { let __args: [G; IN_217] = [__v_0, __v_7, __v_2, __v_3, __v_8]; 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 __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_217] = [__v_9];
-        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_217] = { let __args: [G; IN_217] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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 __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_217] = { let __args: [G; IN_217] = [__v_6, __v_7, __v_2, __v_3, __v_8]; 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 __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_217] = [__v_9];
-        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_208] = { let __args: [G; IN_208] = [__v_6, __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 __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_213] = { let __args: [G; IN_213] = [__v_4, __v_2, __v_3]; 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 __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_215] = { let __args: [G; IN_215] = [__v_10, __v_9, __v_6, __v_3]; 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 __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_216] = { let __args: [G; IN_216] = [__v_0, __v_9, __v_3, __v_11]; 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 __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_217] = [__v_12];
-            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_204] = [__v_12];
+            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -23353,17 +22341,17 @@ fn aiur_fn_217(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4, __v_2, __v_6, __v_3]; 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 __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_216] = { let __args: [G; IN_216] = [__v_0, __v_2, __v_3, __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 __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_217] = [__v_11];
-            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_204] = [__v_11];
+            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -23378,15 +22366,15 @@ fn aiur_fn_217(
   })
 }
 
-const INPUT_SIZE_218: usize = 2;
-const IN_218: usize = 2;
-const OUT_218: usize = 1;
-fn aiur_fn_218(
-  inp: [G; IN_218],
+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_218], ExecError> {
+) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23396,19 +22384,19 @@ fn aiur_fn_218(
     let __v_4: G = __loaded[2];
     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));
+        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_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 __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_218] = { let __args: [G; IN_218] = [__v_4, __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 __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_218] = [__v_8];
-        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_205] = [__v_8];
+        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -23418,15 +22406,15 @@ fn aiur_fn_218(
   })
 }
 
-const INPUT_SIZE_219: usize = 2;
-const IN_219: usize = 2;
-const OUT_219: usize = 1;
-fn aiur_fn_219(
-  inp: [G; IN_219],
+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_219], ExecError> {
+) -> 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];
@@ -23436,8 +22424,8 @@ fn aiur_fn_219(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_219] = [__v_0];
-        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_206] = [__v_0];
+        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23453,18 +22441,18 @@ fn aiur_fn_219(
             let __v_10: G = __loaded[2];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __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 __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_219] = { let __args: [G; IN_219] = [__v_0, __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 __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_219] = [__v_12];
-                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_207] = { let __args: [G; IN_207] = [__v_5, __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 __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 => {
@@ -23497,7 +22485,7 @@ fn aiur_fn_219(
     break '__mc_2 [__v_17];
   },
   0u64 => {
-    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7]; 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 __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_19: G = (__v_17 + __v_18);
@@ -23538,7 +22526,7 @@ fn aiur_fn_219(
         break '__mc_3 [__v_7];
       },
       0u64 => {
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_7, __v_10]; 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 __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];
       },
@@ -23554,10 +22542,10 @@ fn aiur_fn_219(
  };
                     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_219] = { let __args: [G; IN_219] = [__v_15, __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 __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_219] = [__v_16];
-                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_206] = [__v_16];
+                    record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -23573,15 +22561,15 @@ fn aiur_fn_219(
   })
 }
 
-const INPUT_SIZE_220: usize = 2;
-const IN_220: usize = 2;
-const OUT_220: usize = 1;
-fn aiur_fn_220(
-  inp: [G; IN_220],
+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_220], ExecError> {
+) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23598,14 +22586,14 @@ fn aiur_fn_220(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_220] = [__v_8];
-            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_220] = [__v_8];
-            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_207] = [__v_8];
+            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -23621,8 +22609,8 @@ fn aiur_fn_220(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_220] = [__v_8];
-            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_207] = [__v_8];
+            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -23638,27 +22626,27 @@ fn aiur_fn_220(
                 let __v_13: G = __loaded[2];
                 match __v_11.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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_210] = { let __args: [G; IN_210] = [__v_10, __v_13]; 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 __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_220] = { let __args: [G; IN_220] = [__v_4, __v_7]; 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 __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_220] = [__v_17];
-                                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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_220] = [__v_17];
-                                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_207] = [__v_17];
+                                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -23668,16 +22656,16 @@ fn aiur_fn_220(
                           },
                           _ => {
                             let __v_16: G = G::from_u64(0);
-                            let __ret: [G; OUT_220] = [__v_16];
-                            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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_220] = [__v_15];
-                        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_207] = [__v_15];
+                        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -23698,15 +22686,15 @@ fn aiur_fn_220(
   })
 }
 
-const INPUT_SIZE_221: usize = 3;
-const IN_221: usize = 3;
-const OUT_221: usize = 1;
-fn aiur_fn_221(
-  inp: [G; IN_221],
+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_221], ExecError> {
+) -> 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];
@@ -23718,8 +22706,8 @@ fn aiur_fn_221(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_221] = [__v_6];
-        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_208] = [__v_6];
+        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23729,14 +22717,14 @@ fn aiur_fn_221(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_6, __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 __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_221] = { let __args: [G; IN_221] = [__v_5, __v_1, __v_2]; 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 __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_221] = [__v_10];
-                record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_208] = [__v_10];
+                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -23747,7 +22735,7 @@ fn aiur_fn_221(
     break '__mc_0 [__v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_8, __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 __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];
   },
@@ -23760,15 +22748,15 @@ fn aiur_fn_221(
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_221] = [__v_12];
-                    record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_221] = { let __args: [G; IN_221] = [__v_5, __v_1, __v_2]; 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 __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_221] = [__v_12];
-                    record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_208] = [__v_12];
+                    record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23787,15 +22775,15 @@ fn aiur_fn_221(
   })
 }
 
-const INPUT_SIZE_222: usize = 2;
-const IN_222: usize = 2;
-const OUT_222: usize = 1;
-fn aiur_fn_222(
-  inp: [G; IN_222],
+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_222], ExecError> {
+) -> 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];
@@ -23806,8 +22794,8 @@ fn aiur_fn_222(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_222] = [__v_5];
-        record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_209] = [__v_5];
+        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23822,15 +22810,15 @@ fn aiur_fn_222(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_222] = [__v_10];
-                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_222] = { let __args: [G; IN_222] = [__v_4, __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 __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_222] = [__v_10];
-                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_209] = [__v_10];
+                record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -23847,15 +22835,15 @@ fn aiur_fn_222(
   })
 }
 
-const INPUT_SIZE_223: usize = 4;
-const IN_223: usize = 4;
-const OUT_223: usize = 1;
-fn aiur_fn_223(
-  inp: [G; IN_223],
+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_223], 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];
@@ -23868,8 +22856,8 @@ fn aiur_fn_223(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_223] = [__v_7];
-        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_210] = [__v_7];
+        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23879,31 +22867,31 @@ fn aiur_fn_223(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_7, __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 __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_223] = { let __args: [G; IN_223] = [__v_6, __v_1, __v_2, __v_3]; 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 __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_223] = [__v_11];
-                record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_224] = { let __args: [G; IN_224] = [__v_9, __v_2, __v_3]; 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 __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_223] = [__v_12];
-                    record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_223] = { let __args: [G; IN_223] = [__v_6, __v_1, __v_2, __v_3]; 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 __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_223] = [__v_12];
-                    record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_210] = [__v_12];
+                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23922,15 +22910,15 @@ fn aiur_fn_223(
   })
 }
 
-const INPUT_SIZE_224: usize = 3;
-const IN_224: usize = 3;
-const OUT_224: usize = 1;
-fn aiur_fn_224(
-  inp: [G; IN_224],
+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_224], ExecError> {
+) -> Result<[G; OUT_211], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23942,8 +22930,8 @@ fn aiur_fn_224(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_224] = [__v_6];
-        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_211] = [__v_6];
+        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23959,15 +22947,15 @@ fn aiur_fn_224(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_224] = [__v_10];
-                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_224] = { let __args: [G; IN_224] = [__v_5, __v_1, __v_2]; 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 __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_224] = [__v_10];
-                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_211] = [__v_10];
+                    record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23976,10 +22964,10 @@ fn aiur_fn_224(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_1, __v_2]; 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 __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_224] = [__v_9];
-                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_211] = [__v_9];
+                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23993,15 +22981,15 @@ fn aiur_fn_224(
   })
 }
 
-const INPUT_SIZE_225: usize = 2;
-const IN_225: usize = 2;
-const OUT_225: usize = 1;
-fn aiur_fn_225(
-  inp: [G; IN_225],
+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_225], ExecError> {
+) -> Result<[G; OUT_212], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24012,8 +23000,8 @@ fn aiur_fn_225(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_225] = [__v_5];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_212] = [__v_5];
+        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24029,7 +23017,7 @@ fn aiur_fn_225(
     break '__mc_0 [__v_8];
   },
   _ => {
-    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1, __v_5, __v_6]; 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 __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];
   },
@@ -24039,25 +23027,25 @@ fn aiur_fn_225(
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_225] = [__v_9];
-                record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_226] = { let __args: [G; IN_226] = [__v_7, __v_1, __v_5]; 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 __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_225] = [__v_10];
-                    record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_225] = { let __args: [G; IN_225] = [__v_4, __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 __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_225] = [__v_10];
-                    record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_212] = [__v_10];
+                    record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -24079,15 +23067,15 @@ fn aiur_fn_225(
   })
 }
 
-const INPUT_SIZE_226: usize = 3;
-const IN_226: usize = 3;
-const OUT_226: usize = 1;
-fn aiur_fn_226(
-  inp: [G; IN_226],
+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_226], ExecError> {
+) -> 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];
@@ -24099,8 +23087,8 @@ fn aiur_fn_226(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_226] = [__v_6];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_213] = [__v_6];
+        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24109,20 +23097,20 @@ fn aiur_fn_226(
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_1, __v_2, __v_6, __v_7]; 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 __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_226] = [__v_9];
-                record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_226] = { let __args: [G; IN_226] = [__v_5, __v_1, __v_2]; 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 __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_226] = [__v_9];
-                record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_213] = [__v_9];
+                record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -24139,15 +23127,15 @@ fn aiur_fn_226(
   })
 }
 
-const INPUT_SIZE_227: usize = 1;
-const IN_227: usize = 1;
-const OUT_227: usize = 1;
-fn aiur_fn_227(
-  inp: [G; IN_227],
+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_227], ExecError> {
+) -> 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);
@@ -24167,35 +23155,35 @@ fn aiur_fn_227(
     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_216] = { let __args: [G; IN_216] = [__v_0, __v_16, __v_17, __v_13]; 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 __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_218] = { let __args: [G; IN_218] = [__v_18, __v_18]; 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 __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_227] = [__v_19];
-    record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_214] = [__v_19];
+    record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_228: usize = 2;
-const IN_228: usize = 2;
-const OUT_228: usize = 1;
-fn aiur_fn_228(
-  inp: [G; IN_228],
+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_228], ExecError> {
+) -> Result<[G; OUT_215], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __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 __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_228] = [__v_3];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_215] = [__v_3];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24206,19 +23194,19 @@ fn aiur_fn_228(
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_228] = [__v_6];
-            record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_227] = { let __args: [G; IN_227] = [__v_0]; 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 __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_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 __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_225] = { let __args: [G; IN_225] = [__v_6, __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 __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_228] = [__v_8];
-            record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_215] = [__v_8];
+            record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24230,36 +23218,36 @@ fn aiur_fn_228(
   })
 }
 
-const INPUT_SIZE_229: usize = 2;
-const IN_229: usize = 2;
-const OUT_229: usize = 1;
-fn aiur_fn_229(
-  inp: [G; IN_229],
+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_229], 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 __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __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 __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_229] = [__v_3];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_227] = { let __args: [G; IN_227] = [__v_0]; 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 __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_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 __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_220] = { let __args: [G; IN_220] = [__v_3, __v_4]; 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 __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_229] = [__v_5];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_5];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24269,15 +23257,15 @@ fn aiur_fn_229(
   })
 }
 
-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_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_230], 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];
@@ -24287,8 +23275,8 @@ fn aiur_fn_230(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_230] = [__v_1];
-        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_217] = [__v_1];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24298,17 +23286,17 @@ fn aiur_fn_230(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_230] = [__v_0];
-            record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_217] = [__v_0];
+            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __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 __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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_230] = [__v_0];
-                record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_217] = [__v_0];
+                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -24325,19 +23313,19 @@ fn aiur_fn_230(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_15: G = G::from_u64(1);
-                        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 __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_10, __v_13]; 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_16: G = __r_arr[0];
                         let __v_17: G = G::from_u64(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_230] = [__v_18];
-                        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_217] = [__v_18];
+                        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(2);
                         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_230] = [__v_16];
-                        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_217] = [__v_16];
+                        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -24345,8 +23333,8 @@ fn aiur_fn_230(
                   _ => {
                     let __v_12: G = G::from_u64(2);
                     let __v_13: G = { let __values: [G; 3] = [__v_12, __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_230] = [__v_13];
-                    record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_217] = [__v_13];
+                    record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -24362,15 +23350,15 @@ fn aiur_fn_230(
   })
 }
 
-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_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_231], ExecError> {
+) -> Result<[G; OUT_218], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24383,26 +23371,26 @@ fn aiur_fn_231(
         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_231] = [__v_7];
-        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_218] = [__v_7];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1]; 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 __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_231] = [__v_5];
-        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_218] = [__v_5];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1]; 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 __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() {
           1u64 => {
-            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1]; 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 __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_231] = [__v_6];
-            record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_218] = [__v_6];
+            record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -24412,24 +23400,24 @@ fn aiur_fn_231(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_231] = [__v_1];
-                record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_218] = [__v_1];
+                record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __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 __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_231] = [__v_0];
-                    record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_218] = [__v_0];
+                    record.function_queries[218].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_231] = [__v_11];
-                    record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_218] = [__v_11];
+                    record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -24448,15 +23436,15 @@ fn aiur_fn_231(
   })
 }
 
-const INPUT_SIZE_232: usize = 1;
-const IN_232: usize = 1;
-const OUT_232: usize = 1;
-fn aiur_fn_232(
-  inp: [G; IN_232],
+const INPUT_SIZE_219: usize = 1;
+const IN_219: usize = 1;
+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_232], ExecError> {
+) -> Result<[G; OUT_219], 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 };
@@ -24468,48 +23456,48 @@ fn aiur_fn_232(
         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_232] = [__v_6];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_219] = [__v_6];
+        record.function_queries[219].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_232] = [__v_6];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_219] = [__v_6];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2]; 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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_2]; 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 = 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_232] = [__v_7];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_219] = [__v_7];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2]; 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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_2]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3]; 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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3]; 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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __v_5]; 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 __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_232] = [__v_6];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_219] = [__v_6];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2]; 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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_2]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3]; 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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3]; 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_5]; 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_232] = [__v_6];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_219] = [__v_6];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24519,15 +23507,15 @@ fn aiur_fn_232(
   })
 }
 
-const INPUT_SIZE_233: usize = 2;
-const IN_233: usize = 2;
-const OUT_233: usize = 1;
-fn aiur_fn_233(
-  inp: [G; IN_233],
+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_233], ExecError> {
+) -> 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];
@@ -24540,47 +23528,47 @@ fn aiur_fn_233(
         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_233] = [__v_7];
-        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_220] = [__v_7];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_3, __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_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_233] = [__v_8];
-        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_220] = [__v_8];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_3, __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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __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_6: G = __r_arr[0];
-        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 __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_233] = [__v_7];
-        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_220] = [__v_7];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_3, __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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __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 __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_233] = [__v_7];
-        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_220] = [__v_7];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_3]; 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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_233] = [__v_5];
-        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_220] = [__v_5];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24590,15 +23578,15 @@ fn aiur_fn_233(
   })
 }
 
-const INPUT_SIZE_234: usize = 2;
-const IN_234: usize = 2;
-const OUT_234: usize = 1;
-fn aiur_fn_234(
-  inp: [G; IN_234],
+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_234], 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];
@@ -24611,19 +23599,19 @@ fn aiur_fn_234(
         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_234] = [__v_7];
-        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_221] = [__v_7];
+        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_3, __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __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_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_234] = [__v_8];
-        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_221] = [__v_8];
+        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24633,15 +23621,15 @@ fn aiur_fn_234(
   })
 }
 
-const INPUT_SIZE_235: usize = 2;
-const IN_235: usize = 2;
-const OUT_235: usize = 1;
-fn aiur_fn_235(
-  inp: [G; IN_235],
+const INPUT_SIZE_222: usize = 2;
+const IN_222: usize = 2;
+const OUT_222: usize = 1;
+fn aiur_fn_222(
+  inp: [G; IN_222],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_235], ExecError> {
+) -> Result<[G; OUT_222], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24651,30 +23639,30 @@ fn aiur_fn_235(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_235] = [__v_0];
-        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_222] = [__v_0];
+        record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0, __v_1]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_235] = [__v_5];
-        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_222] = [__v_5];
+        record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_236: usize = 2;
-const IN_236: usize = 2;
-const OUT_236: usize = 1;
-fn aiur_fn_236(
-  inp: [G; IN_236],
+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_236], ExecError> {
+) -> 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];
@@ -24688,94 +23676,94 @@ fn aiur_fn_236(
         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_236] = [__v_8];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_8];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_3, __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_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_236] = [__v_9];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_9];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(2);
-        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __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_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_236] = [__v_9];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_9];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_6: G = G::from_u64(3);
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4, __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_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_236] = [__v_10];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_10];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_6: G = G::from_u64(4);
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4, __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_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_236] = [__v_10];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_10];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_6: G = G::from_u64(5);
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4, __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_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_236] = [__v_10];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_10];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(6);
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __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_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_236] = [__v_10];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_10];
+        record.function_queries[223].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_236] = [__v_8];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_8];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_6: G = G::from_u64(8);
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __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_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_236] = [__v_8];
-        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_8];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24785,15 +23773,15 @@ fn aiur_fn_236(
   })
 }
 
-const INPUT_SIZE_237: usize = 2;
-const IN_237: usize = 2;
-const OUT_237: usize = 1;
-fn aiur_fn_237(
-  inp: [G; IN_237],
+const INPUT_SIZE_224: usize = 2;
+const IN_224: usize = 2;
+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_237], ExecError> {
+) -> Result<[G; OUT_224], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24824,14 +23812,14 @@ fn aiur_fn_237(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_237] = [__v_22];
-            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_224] = [__v_22];
+            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_237] = [__v_22];
-            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_224] = [__v_22];
+            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24851,25 +23839,25 @@ fn aiur_fn_237(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_237] = [__v_22];
-            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_224] = [__v_22];
+            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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 __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_237] = { let __args: [G; IN_237] = [__v_11, __v_21]; 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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_11, __v_21]; 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_237] = [__v_23];
-                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_224] = [__v_23];
+                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_237] = [__v_23];
-                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_224] = [__v_23];
+                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -24889,15 +23877,15 @@ fn aiur_fn_237(
   })
 }
 
-const INPUT_SIZE_238: usize = 2;
-const IN_238: usize = 2;
-const OUT_238: usize = 1;
-fn aiur_fn_238(
-  inp: [G; IN_238],
+const INPUT_SIZE_225: usize = 2;
+const IN_225: usize = 2;
+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_238], 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];
@@ -24914,14 +23902,14 @@ fn aiur_fn_238(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_238] = [__v_8];
-            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_225] = [__v_8];
+            record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_238] = [__v_8];
-            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_225] = [__v_8];
+            record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24934,24 +23922,24 @@ fn aiur_fn_238(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_238] = [__v_8];
-            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_225] = [__v_8];
+            record.function_queries[225].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_238] = { let __args: [G; IN_238] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4, __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_9: G = __r_arr[0];
-                let __ret: [G; OUT_238] = [__v_9];
-                record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_225] = [__v_9];
+                record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_238] = [__v_9];
-                record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_225] = [__v_9];
+                record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -24968,15 +23956,15 @@ fn aiur_fn_238(
   })
 }
 
-const INPUT_SIZE_239: usize = 4;
-const IN_239: usize = 4;
-const OUT_239: usize = 1;
-fn aiur_fn_239(
-  inp: [G; IN_239],
+const INPUT_SIZE_226: usize = 4;
+const IN_226: usize = 4;
+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_239], ExecError> {
+) -> 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];
@@ -24986,16 +23974,16 @@ fn aiur_fn_239(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_1, __v_3]; 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_4: G = __r_arr[0];
-            let __ret: [G; OUT_239] = [__v_4];
-            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_226] = [__v_4];
+            record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_239] = [__v_4];
-            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_226] = [__v_4];
+            record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -25003,16 +23991,16 @@ fn aiur_fn_239(
       1u64 => {
         match __v_2.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_1, __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_4: G = __r_arr[0];
-            let __ret: [G; OUT_239] = [__v_4];
-            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_226] = [__v_4];
+            record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_239] = [__v_4];
-            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_226] = [__v_4];
+            record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -25024,15 +24012,15 @@ fn aiur_fn_239(
   })
 }
 
-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_227: usize = 0;
+const IN_227: usize = 0;
+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_240], ExecError> {
+) -> Result<[G; OUT_227], 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);
@@ -25067,21 +24055,21 @@ fn aiur_fn_240(
     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_240] = [__v_32];
-    record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_227] = [__v_32];
+    record.function_queries[227].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_228: usize = 0;
+const IN_228: usize = 0;
+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_241], ExecError> {
+) -> Result<[G; OUT_228], 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);
@@ -25116,21 +24104,21 @@ fn aiur_fn_241(
     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_241] = [__v_32];
-    record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_228] = [__v_32];
+    record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_229: usize = 0;
+const IN_229: usize = 0;
+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_242], ExecError> {
+) -> Result<[G; OUT_229], 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);
@@ -25165,21 +24153,21 @@ fn aiur_fn_242(
     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_242] = [__v_32];
-    record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_229] = [__v_32];
+    record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_230: usize = 0;
+const IN_230: usize = 0;
+const OUT_230: usize = 1;
+fn aiur_fn_230(
+  inp: [G; IN_230],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_243], ExecError> {
+) -> Result<[G; OUT_230], 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);
@@ -25214,21 +24202,21 @@ fn aiur_fn_243(
     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_243] = [__v_32];
-    record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_230] = [__v_32];
+    record.function_queries[230].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_231: usize = 0;
+const IN_231: usize = 0;
+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_244], ExecError> {
+) -> Result<[G; OUT_231], 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);
@@ -25263,21 +24251,21 @@ fn aiur_fn_244(
     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_244] = [__v_32];
-    record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_231] = [__v_32];
+    record.function_queries[231].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_232: usize = 0;
+const IN_232: usize = 0;
+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_245], ExecError> {
+) -> Result<[G; OUT_232], 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);
@@ -25312,21 +24300,21 @@ fn aiur_fn_245(
     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_245] = [__v_32];
-    record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_232] = [__v_32];
+    record.function_queries[232].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_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_246], ExecError> {
+) -> Result<[G; OUT_233], 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);
@@ -25361,21 +24349,21 @@ fn aiur_fn_246(
     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_246] = [__v_32];
-    record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_233] = [__v_32];
+    record.function_queries[233].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_234: usize = 0;
+const IN_234: usize = 0;
+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_247], ExecError> {
+) -> Result<[G; OUT_234], 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);
@@ -25410,21 +24398,21 @@ fn aiur_fn_247(
     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_247] = [__v_32];
-    record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_234] = [__v_32];
+    record.function_queries[234].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_235: usize = 0;
+const IN_235: usize = 0;
+const OUT_235: usize = 1;
+fn aiur_fn_235(
+  inp: [G; IN_235],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_248], ExecError> {
+) -> Result<[G; OUT_235], 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);
@@ -25459,21 +24447,21 @@ fn aiur_fn_248(
     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_248] = [__v_32];
-    record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_235] = [__v_32];
+    record.function_queries[235].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_236: usize = 0;
+const IN_236: usize = 0;
+const OUT_236: usize = 1;
+fn aiur_fn_236(
+  inp: [G; IN_236],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_249], ExecError> {
+) -> Result<[G; OUT_236], 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);
@@ -25508,21 +24496,21 @@ fn aiur_fn_249(
     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_249] = [__v_32];
-    record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_236] = [__v_32];
+    record.function_queries[236].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_237: usize = 0;
+const IN_237: usize = 0;
+const OUT_237: usize = 1;
+fn aiur_fn_237(
+  inp: [G; IN_237],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_250], ExecError> {
+) -> Result<[G; OUT_237], 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);
@@ -25557,21 +24545,21 @@ fn aiur_fn_250(
     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_250] = [__v_32];
-    record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_237] = [__v_32];
+    record.function_queries[237].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_238: usize = 0;
+const IN_238: usize = 0;
+const OUT_238: usize = 1;
+fn aiur_fn_238(
+  inp: [G; IN_238],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_251], ExecError> {
+) -> Result<[G; OUT_238], 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);
@@ -25606,21 +24594,21 @@ fn aiur_fn_251(
     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_251] = [__v_32];
-    record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_238] = [__v_32];
+    record.function_queries[238].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_239: usize = 0;
+const IN_239: usize = 0;
+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_252], ExecError> {
+) -> Result<[G; OUT_239], 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);
@@ -25655,21 +24643,21 @@ fn aiur_fn_252(
     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_252] = [__v_32];
-    record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_239] = [__v_32];
+    record.function_queries[239].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_240: usize = 0;
+const IN_240: usize = 0;
+const OUT_240: usize = 1;
+fn aiur_fn_240(
+  inp: [G; IN_240],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_253], ExecError> {
+) -> Result<[G; OUT_240], 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);
@@ -25704,21 +24692,21 @@ fn aiur_fn_253(
     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_253] = [__v_32];
-    record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_240] = [__v_32];
+    record.function_queries[240].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_241: usize = 0;
+const IN_241: usize = 0;
+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_254], ExecError> {
+) -> Result<[G; OUT_241], 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);
@@ -25753,21 +24741,21 @@ fn aiur_fn_254(
     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_254] = [__v_32];
-    record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_241] = [__v_32];
+    record.function_queries[241].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_242: usize = 0;
+const IN_242: usize = 0;
+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_255], ExecError> {
+) -> Result<[G; OUT_242], 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);
@@ -25802,21 +24790,21 @@ fn aiur_fn_255(
     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_255] = [__v_32];
-    record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_242] = [__v_32];
+    record.function_queries[242].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_243: usize = 0;
+const IN_243: usize = 0;
+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_256], ExecError> {
+) -> Result<[G; OUT_243], 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);
@@ -25851,21 +24839,21 @@ fn aiur_fn_256(
     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_256] = [__v_32];
-    record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_243] = [__v_32];
+    record.function_queries[243].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_244: usize = 0;
+const IN_244: usize = 0;
+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_257], ExecError> {
+) -> Result<[G; OUT_244], 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);
@@ -25900,21 +24888,21 @@ fn aiur_fn_257(
     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_257] = [__v_32];
-    record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_244] = [__v_32];
+    record.function_queries[244].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_245: usize = 0;
+const IN_245: usize = 0;
+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_258], ExecError> {
+) -> Result<[G; OUT_245], 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);
@@ -25949,21 +24937,21 @@ fn aiur_fn_258(
     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_258] = [__v_32];
-    record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_245] = [__v_32];
+    record.function_queries[245].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_246: usize = 0;
+const IN_246: usize = 0;
+const OUT_246: usize = 1;
+fn aiur_fn_246(
+  inp: [G; IN_246],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_259], ExecError> {
+) -> Result<[G; OUT_246], 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);
@@ -25998,21 +24986,21 @@ fn aiur_fn_259(
     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_259] = [__v_32];
-    record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_246] = [__v_32];
+    record.function_queries[246].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_247: usize = 0;
+const IN_247: usize = 0;
+const OUT_247: usize = 1;
+fn aiur_fn_247(
+  inp: [G; IN_247],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_260], ExecError> {
+) -> Result<[G; OUT_247], 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);
@@ -26047,21 +25035,21 @@ fn aiur_fn_260(
     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_260] = [__v_32];
-    record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_247] = [__v_32];
+    record.function_queries[247].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_248: usize = 0;
+const IN_248: usize = 0;
+const OUT_248: usize = 1;
+fn aiur_fn_248(
+  inp: [G; IN_248],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_261], ExecError> {
+) -> Result<[G; OUT_248], 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);
@@ -26096,21 +25084,21 @@ fn aiur_fn_261(
     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_261] = [__v_32];
-    record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_248] = [__v_32];
+    record.function_queries[248].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_249: usize = 0;
+const IN_249: usize = 0;
+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_262], ExecError> {
+) -> Result<[G; OUT_249], 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);
@@ -26145,21 +25133,21 @@ fn aiur_fn_262(
     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_262] = [__v_32];
-    record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_249] = [__v_32];
+    record.function_queries[249].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_250: usize = 0;
+const IN_250: usize = 0;
+const OUT_250: usize = 1;
+fn aiur_fn_250(
+  inp: [G; IN_250],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_263], ExecError> {
+) -> Result<[G; OUT_250], 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);
@@ -26194,21 +25182,21 @@ fn aiur_fn_263(
     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_263] = [__v_32];
-    record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_250] = [__v_32];
+    record.function_queries[250].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_251: usize = 0;
+const IN_251: usize = 0;
+const OUT_251: usize = 1;
+fn aiur_fn_251(
+  inp: [G; IN_251],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_264], ExecError> {
+) -> Result<[G; OUT_251], 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);
@@ -26243,21 +25231,21 @@ fn aiur_fn_264(
     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_264] = [__v_32];
-    record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_251] = [__v_32];
+    record.function_queries[251].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_252: usize = 0;
+const IN_252: usize = 0;
+const OUT_252: usize = 1;
+fn aiur_fn_252(
+  inp: [G; IN_252],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_265], ExecError> {
+) -> Result<[G; OUT_252], 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);
@@ -26292,21 +25280,21 @@ fn aiur_fn_265(
     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_265] = [__v_32];
-    record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_252] = [__v_32];
+    record.function_queries[252].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_253: usize = 0;
+const IN_253: usize = 0;
+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_266], ExecError> {
+) -> Result<[G; OUT_253], 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);
@@ -26341,21 +25329,21 @@ fn aiur_fn_266(
     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_266] = [__v_32];
-    record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_253] = [__v_32];
+    record.function_queries[253].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_254: usize = 0;
+const IN_254: usize = 0;
+const OUT_254: usize = 1;
+fn aiur_fn_254(
+  inp: [G; IN_254],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_267], ExecError> {
+) -> Result<[G; OUT_254], 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);
@@ -26390,21 +25378,21 @@ fn aiur_fn_267(
     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_267] = [__v_32];
-    record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_254] = [__v_32];
+    record.function_queries[254].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_255: usize = 0;
+const IN_255: usize = 0;
+const OUT_255: usize = 1;
+fn aiur_fn_255(
+  inp: [G; IN_255],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_268], ExecError> {
+) -> Result<[G; OUT_255], 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);
@@ -26439,21 +25427,21 @@ fn aiur_fn_268(
     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_268] = [__v_32];
-    record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_255] = [__v_32];
+    record.function_queries[255].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_256: usize = 0;
+const IN_256: usize = 0;
+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_269], ExecError> {
+) -> Result<[G; OUT_256], 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);
@@ -26488,21 +25476,21 @@ fn aiur_fn_269(
     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_269] = [__v_32];
-    record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_256] = [__v_32];
+    record.function_queries[256].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_257: usize = 0;
+const IN_257: usize = 0;
+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_270], ExecError> {
+) -> Result<[G; OUT_257], 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);
@@ -26537,21 +25525,21 @@ fn aiur_fn_270(
     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_270] = [__v_32];
-    record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_257] = [__v_32];
+    record.function_queries[257].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_258: usize = 0;
+const IN_258: usize = 0;
+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_271], ExecError> {
+) -> Result<[G; OUT_258], 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);
@@ -26586,21 +25574,21 @@ fn aiur_fn_271(
     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_271] = [__v_32];
-    record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_258] = [__v_32];
+    record.function_queries[258].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_259: usize = 0;
+const IN_259: usize = 0;
+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_272], ExecError> {
+) -> Result<[G; OUT_259], 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);
@@ -26635,21 +25623,21 @@ fn aiur_fn_272(
     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_272] = [__v_32];
-    record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_259] = [__v_32];
+    record.function_queries[259].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_260: usize = 0;
+const IN_260: usize = 0;
+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_273], ExecError> {
+) -> Result<[G; OUT_260], 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);
@@ -26684,21 +25672,21 @@ fn aiur_fn_273(
     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_273] = [__v_32];
-    record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_260] = [__v_32];
+    record.function_queries[260].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_261: usize = 0;
+const IN_261: usize = 0;
+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_274], ExecError> {
+) -> Result<[G; OUT_261], 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);
@@ -26733,21 +25721,21 @@ fn aiur_fn_274(
     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_274] = [__v_32];
-    record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_261] = [__v_32];
+    record.function_queries[261].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_262: usize = 0;
+const IN_262: usize = 0;
+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_275], ExecError> {
+) -> Result<[G; OUT_262], 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);
@@ -26782,21 +25770,21 @@ fn aiur_fn_275(
     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_275] = [__v_32];
-    record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_262] = [__v_32];
+    record.function_queries[262].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_263: usize = 0;
+const IN_263: usize = 0;
+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_276], ExecError> {
+) -> Result<[G; OUT_263], 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);
@@ -26831,21 +25819,21 @@ fn aiur_fn_276(
     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_276] = [__v_32];
-    record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_263] = [__v_32];
+    record.function_queries[263].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_264: usize = 0;
+const IN_264: usize = 0;
+const OUT_264: usize = 1;
+fn aiur_fn_264(
+  inp: [G; IN_264],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_277], ExecError> {
+) -> Result<[G; OUT_264], 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);
@@ -26880,21 +25868,21 @@ fn aiur_fn_277(
     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_277] = [__v_32];
-    record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_264] = [__v_32];
+    record.function_queries[264].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_265: usize = 0;
+const IN_265: usize = 0;
+const OUT_265: usize = 1;
+fn aiur_fn_265(
+  inp: [G; IN_265],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_278], ExecError> {
+) -> Result<[G; OUT_265], 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);
@@ -26929,21 +25917,21 @@ fn aiur_fn_278(
     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_278] = [__v_32];
-    record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_265] = [__v_32];
+    record.function_queries[265].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_266: usize = 0;
+const IN_266: usize = 0;
+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_279], ExecError> {
+) -> Result<[G; OUT_266], 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);
@@ -26978,21 +25966,21 @@ fn aiur_fn_279(
     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_279] = [__v_32];
-    record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_266] = [__v_32];
+    record.function_queries[266].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_267: usize = 0;
+const IN_267: usize = 0;
+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_280], ExecError> {
+) -> Result<[G; OUT_267], 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);
@@ -27027,21 +26015,21 @@ fn aiur_fn_280(
     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_280] = [__v_32];
-    record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_267] = [__v_32];
+    record.function_queries[267].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_268: usize = 0;
+const IN_268: usize = 0;
+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_281], ExecError> {
+) -> Result<[G; OUT_268], 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);
@@ -27076,21 +26064,21 @@ fn aiur_fn_281(
     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_281] = [__v_32];
-    record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_268] = [__v_32];
+    record.function_queries[268].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_269: usize = 0;
+const IN_269: usize = 0;
+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_282], ExecError> {
+) -> Result<[G; OUT_269], 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);
@@ -27125,21 +26113,21 @@ fn aiur_fn_282(
     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_282] = [__v_32];
-    record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_269] = [__v_32];
+    record.function_queries[269].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_270: usize = 0;
+const IN_270: usize = 0;
+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_283], ExecError> {
+) -> Result<[G; OUT_270], 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);
@@ -27174,21 +26162,21 @@ fn aiur_fn_283(
     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_283] = [__v_32];
-    record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_270] = [__v_32];
+    record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_271: usize = 0;
+const IN_271: usize = 0;
+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_284], ExecError> {
+) -> Result<[G; OUT_271], 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);
@@ -27223,21 +26211,21 @@ fn aiur_fn_284(
     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_284] = [__v_32];
-    record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_271] = [__v_32];
+    record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_272: usize = 0;
+const IN_272: usize = 0;
+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_285], ExecError> {
+) -> Result<[G; OUT_272], 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);
@@ -27272,21 +26260,21 @@ fn aiur_fn_285(
     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_285] = [__v_32];
-    record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_272] = [__v_32];
+    record.function_queries[272].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_273: usize = 0;
+const IN_273: usize = 0;
+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_286], ExecError> {
+) -> Result<[G; OUT_273], 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);
@@ -27321,21 +26309,21 @@ fn aiur_fn_286(
     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_286] = [__v_32];
-    record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_273] = [__v_32];
+    record.function_queries[273].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_274: usize = 0;
+const IN_274: usize = 0;
+const OUT_274: usize = 1;
+fn aiur_fn_274(
+  inp: [G; IN_274],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_287], ExecError> {
+) -> Result<[G; OUT_274], 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);
@@ -27370,21 +26358,21 @@ fn aiur_fn_287(
     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_287] = [__v_32];
-    record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_274] = [__v_32];
+    record.function_queries[274].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_275: usize = 0;
+const IN_275: usize = 0;
+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_288], ExecError> {
+) -> Result<[G; OUT_275], 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);
@@ -27419,21 +26407,21 @@ fn aiur_fn_288(
     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_288] = [__v_32];
-    record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_275] = [__v_32];
+    record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_276: usize = 0;
+const IN_276: usize = 0;
+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_289], ExecError> {
+) -> Result<[G; OUT_276], 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);
@@ -27468,21 +26456,21 @@ fn aiur_fn_289(
     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_289] = [__v_32];
-    record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_276] = [__v_32];
+    record.function_queries[276].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_277: usize = 0;
+const IN_277: usize = 0;
+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_290], ExecError> {
+) -> Result<[G; OUT_277], 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);
@@ -27517,21 +26505,21 @@ fn aiur_fn_290(
     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_290] = [__v_32];
-    record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_277] = [__v_32];
+    record.function_queries[277].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_278: usize = 0;
+const IN_278: usize = 0;
+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_291], ExecError> {
+) -> Result<[G; OUT_278], 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);
@@ -27566,21 +26554,21 @@ fn aiur_fn_291(
     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_291] = [__v_32];
-    record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_278] = [__v_32];
+    record.function_queries[278].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_279: usize = 0;
+const IN_279: usize = 0;
+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_292], ExecError> {
+) -> Result<[G; OUT_279], 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);
@@ -27615,21 +26603,21 @@ fn aiur_fn_292(
     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_292] = [__v_32];
-    record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_279] = [__v_32];
+    record.function_queries[279].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_280: usize = 0;
+const IN_280: usize = 0;
+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_293], ExecError> {
+) -> Result<[G; OUT_280], 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);
@@ -27664,21 +26652,21 @@ fn aiur_fn_293(
     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_293] = [__v_32];
-    record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_280] = [__v_32];
+    record.function_queries[280].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_281: usize = 0;
+const IN_281: usize = 0;
+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_294], ExecError> {
+) -> Result<[G; OUT_281], 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);
@@ -27713,21 +26701,21 @@ fn aiur_fn_294(
     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_294] = [__v_32];
-    record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_281] = [__v_32];
+    record.function_queries[281].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],
+const INPUT_SIZE_282: usize = 0;
+const IN_282: usize = 0;
+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_295], ExecError> {
+) -> Result<[G; OUT_282], 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);
@@ -27762,21 +26750,21 @@ fn aiur_fn_295(
     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_295] = [__v_32];
-    record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_282] = [__v_32];
+    record.function_queries[282].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],
+const INPUT_SIZE_283: usize = 0;
+const IN_283: usize = 0;
+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_296], ExecError> {
+) -> Result<[G; OUT_283], 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);
@@ -27811,21 +26799,21 @@ fn aiur_fn_296(
     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_296] = [__v_32];
-    record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_283] = [__v_32];
+    record.function_queries[283].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],
+const INPUT_SIZE_284: usize = 0;
+const IN_284: usize = 0;
+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_297], ExecError> {
+) -> Result<[G; OUT_284], 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);
@@ -27860,21 +26848,21 @@ fn aiur_fn_297(
     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_297] = [__v_32];
-    record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_284] = [__v_32];
+    record.function_queries[284].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],
+const INPUT_SIZE_285: usize = 0;
+const IN_285: usize = 0;
+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_298], ExecError> {
+) -> Result<[G; OUT_285], 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);
@@ -27909,21 +26897,21 @@ fn aiur_fn_298(
     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_298] = [__v_32];
-    record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_285] = [__v_32];
+    record.function_queries[285].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_286: usize = 0;
+const IN_286: usize = 0;
+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_299], ExecError> {
+) -> Result<[G; OUT_286], 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);
@@ -27958,21 +26946,21 @@ fn aiur_fn_299(
     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_299] = [__v_32];
-    record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_286] = [__v_32];
+    record.function_queries[286].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_287: usize = 0;
+const IN_287: usize = 0;
+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_300], ExecError> {
+) -> Result<[G; OUT_287], 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);
@@ -28007,21 +26995,21 @@ fn aiur_fn_300(
     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_300] = [__v_32];
-    record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_287] = [__v_32];
+    record.function_queries[287].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_288: usize = 0;
+const IN_288: usize = 0;
+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_301], ExecError> {
+) -> Result<[G; OUT_288], 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);
@@ -28056,21 +27044,21 @@ fn aiur_fn_301(
     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_301] = [__v_32];
-    record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_288] = [__v_32];
+    record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_289: usize = 0;
+const IN_289: usize = 0;
+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_302], ExecError> {
+) -> Result<[G; OUT_289], 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);
@@ -28105,21 +27093,21 @@ fn aiur_fn_302(
     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_302] = [__v_32];
-    record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_289] = [__v_32];
+    record.function_queries[289].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_290: usize = 0;
+const IN_290: usize = 0;
+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_303], ExecError> {
+) -> Result<[G; OUT_290], 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);
@@ -28154,21 +27142,21 @@ fn aiur_fn_303(
     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_303] = [__v_32];
-    record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_290] = [__v_32];
+    record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_304: usize = 0;
-const IN_304: usize = 0;
-const OUT_304: usize = 1;
-fn aiur_fn_304(
-  inp: [G; IN_304],
+const INPUT_SIZE_291: usize = 0;
+const IN_291: usize = 0;
+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_304], ExecError> {
+) -> Result<[G; OUT_291], 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);
@@ -28203,21 +27191,21 @@ fn aiur_fn_304(
     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_304] = [__v_32];
-    record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_291] = [__v_32];
+    record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_305: usize = 0;
-const IN_305: usize = 0;
-const OUT_305: usize = 1;
-fn aiur_fn_305(
-  inp: [G; IN_305],
+const INPUT_SIZE_292: usize = 0;
+const IN_292: usize = 0;
+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_305], ExecError> {
+) -> Result<[G; OUT_292], 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);
@@ -28252,21 +27240,21 @@ fn aiur_fn_305(
     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_305] = [__v_32];
-    record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_292] = [__v_32];
+    record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_306: usize = 0;
-const IN_306: usize = 0;
-const OUT_306: usize = 1;
-fn aiur_fn_306(
-  inp: [G; IN_306],
+const INPUT_SIZE_293: usize = 0;
+const IN_293: usize = 0;
+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_306], ExecError> {
+) -> Result<[G; OUT_293], 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);
@@ -28301,21 +27289,21 @@ fn aiur_fn_306(
     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_306] = [__v_32];
-    record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_293] = [__v_32];
+    record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_307: usize = 0;
-const IN_307: usize = 0;
-const OUT_307: usize = 1;
-fn aiur_fn_307(
-  inp: [G; IN_307],
+const INPUT_SIZE_294: usize = 0;
+const IN_294: usize = 0;
+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_307], ExecError> {
+) -> Result<[G; OUT_294], 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);
@@ -28350,21 +27338,21 @@ fn aiur_fn_307(
     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_307] = [__v_32];
-    record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_294] = [__v_32];
+    record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_308: usize = 0;
-const IN_308: usize = 0;
-const OUT_308: usize = 1;
-fn aiur_fn_308(
-  inp: [G; IN_308],
+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_308], ExecError> {
+) -> Result<[G; OUT_295], 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);
@@ -28399,21 +27387,21 @@ fn aiur_fn_308(
     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_308] = [__v_32];
-    record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_295] = [__v_32];
+    record.function_queries[295].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_296: usize = 1;
+const IN_296: usize = 1;
+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_309], ExecError> {
+) -> Result<[G; OUT_296], 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 };
@@ -28442,8 +27430,8 @@ fn aiur_fn_309(
         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_309] = [__v_23];
-        record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_296] = [__v_23];
+        record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -28455,7 +27443,7 @@ fn aiur_fn_309(
         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_11] = { let __args: [G; IN_11] = [__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[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_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];
@@ -28469,17 +27457,17 @@ fn aiur_fn_309(
           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_309] = [__v_29];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_296] = [__v_29];
+            record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_28: G = G::from_u64(0);
-            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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_10]; 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_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_309] = [__v_30];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_296] = [__v_30];
+            record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -28491,15 +27479,15 @@ fn aiur_fn_309(
   })
 }
 
-const INPUT_SIZE_310: usize = 3;
-const IN_310: usize = 3;
-const OUT_310: usize = 1;
-fn aiur_fn_310(
-  inp: [G; IN_310],
+const INPUT_SIZE_297: usize = 3;
+const IN_297: usize = 3;
+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_310], ExecError> {
+) -> Result<[G; OUT_297], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28519,15 +27507,15 @@ fn aiur_fn_310(
       1u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_310] = [__v_1];
-            record.function_queries[310].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);
           },
           _ => {
-            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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__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_13: G = __r_arr[0];
-            let __ret: [G; OUT_310] = [__v_13];
-            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_297] = [__v_13];
+            record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -28548,21 +27536,21 @@ fn aiur_fn_310(
           1u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_310] = [__v_0];
-                record.function_queries[310].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);
               },
               _ => {
-                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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_310] = [__v_23];
-                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_297] = [__v_23];
+                record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            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, __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[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_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];
@@ -28579,7 +27567,7 @@ fn aiur_fn_310(
             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_11] = { let __args: [G; IN_11] = [__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[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_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];
@@ -28591,11 +27579,11 @@ fn aiur_fn_310(
             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_310] = { let __args: [G; IN_310] = [__v_12, __v_22, __v_48]; 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_297] = { let __args: [G; IN_297] = [__v_12, __v_22, __v_48]; 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_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_310] = [__v_51];
-            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_297] = [__v_51];
+            record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28610,36 +27598,36 @@ fn aiur_fn_310(
   })
 }
 
-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_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_311], 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 __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __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 __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_311] = [__v_3];
-    record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_298] = [__v_3];
+    record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_312: usize = 16;
-const IN_312: usize = 16;
-const OUT_312: usize = 9;
-fn aiur_fn_312(
-  inp: [G; IN_312],
+const INPUT_SIZE_299: usize = 16;
+const IN_299: usize = 16;
+const OUT_299: usize = 9;
+fn aiur_fn_299(
+  inp: [G; IN_299],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_312], 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];
@@ -28709,21 +27697,21 @@ fn aiur_fn_312(
     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_312] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_299] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_313: usize = 3;
-const IN_313: usize = 3;
-const OUT_313: usize = 2;
-fn aiur_fn_313(
-  inp: [G; IN_313],
+const INPUT_SIZE_300: usize = 3;
+const IN_300: usize = 3;
+const OUT_300: usize = 2;
+fn aiur_fn_300(
+  inp: [G; IN_300],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_313], 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];
@@ -28757,8 +27745,8 @@ fn aiur_fn_313(
             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_313] = [__v_25, __v_2];
-            record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_300] = [__v_25, __v_2];
+            record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -28766,8 +27754,8 @@ fn aiur_fn_313(
             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_313] = [__v_25, __v_26];
-            record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_300] = [__v_25, __v_26];
+            record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28792,8 +27780,8 @@ fn aiur_fn_313(
             match __v_2.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_313] = [__v_0, __v_23];
-                record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_300] = [__v_0, __v_23];
+                record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -28805,7 +27793,7 @@ fn aiur_fn_313(
                 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_312] = { let __args: [G; IN_312] = [__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[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 __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__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[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_31: G = __r_arr[0];
                 let __v_32: G = __r_arr[1];
                 let __v_33: G = __r_arr[2];
@@ -28818,19 +27806,19 @@ fn aiur_fn_313(
                 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_313] = { let __args: [G; IN_313] = [__v_12, __v_42, __v_39]; 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 __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_12, __v_42, __v_39]; 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_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_313] = [__v_46, __v_44];
-                record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_300] = [__v_46, __v_44];
+                record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__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[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 __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__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[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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -28847,7 +27835,7 @@ fn aiur_fn_313(
             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_312] = { let __args: [G; IN_312] = [__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[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 __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__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[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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -28858,13 +27846,13 @@ fn aiur_fn_313(
             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_313] = { let __args: [G; IN_313] = [__v_12, __v_22, __v_48]; 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 __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_12, __v_22, __v_48]; 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_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_313] = [__v_52, __v_50];
-            record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_300] = [__v_52, __v_50];
+            record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28879,15 +27867,15 @@ fn aiur_fn_313(
   })
 }
 
-const INPUT_SIZE_314: usize = 1;
-const IN_314: usize = 1;
-const OUT_314: usize = 1;
-fn aiur_fn_314(
-  inp: [G; IN_314],
+const INPUT_SIZE_301: usize = 1;
+const IN_301: usize = 1;
+const OUT_301: usize = 1;
+fn aiur_fn_301(
+  inp: [G; IN_301],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_314], ExecError> {
+) -> Result<[G; OUT_301], 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 };
@@ -28906,12 +27894,12 @@ fn aiur_fn_314(
         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_314] = [__v_13];
-        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_301] = [__v_13];
+        record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_10]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_10]; 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_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];
@@ -28933,8 +27921,8 @@ fn aiur_fn_314(
                 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_314] = [__v_25];
-                record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_301] = [__v_25];
+                record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -28943,8 +27931,8 @@ fn aiur_fn_314(
                 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_314] = [__v_27];
-                record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_301] = [__v_27];
+                record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -28955,8 +27943,8 @@ fn aiur_fn_314(
           _ => {
             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_314] = [__v_23];
-            record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_301] = [__v_23];
+            record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -28968,20 +27956,20 @@ fn aiur_fn_314(
   })
 }
 
-const INPUT_SIZE_315: usize = 2;
-const IN_315: usize = 2;
-const OUT_315: usize = 1;
-fn aiur_fn_315(
-  inp: [G; IN_315],
+const INPUT_SIZE_302: usize = 2;
+const IN_302: usize = 2;
+const OUT_302: usize = 1;
+fn aiur_fn_302(
+  inp: [G; IN_302],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_315], 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];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1, __v_2]; 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 __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -28989,15 +27977,15 @@ fn aiur_fn_315(
         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_315] = [__v_7];
-        record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_302] = [__v_7];
+        record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; 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 = __r_arr[0];
-        let __ret: [G; OUT_315] = [__v_5];
-        record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_302] = [__v_5];
+        record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29007,19 +27995,19 @@ fn aiur_fn_315(
   })
 }
 
-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_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_316], 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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_1]; 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_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];
@@ -29035,29 +28023,29 @@ fn aiur_fn_316(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_316] = [__v_13];
-        record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_303] = [__v_13];
+        record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_316] = [__v_13];
-        record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_303] = [__v_13];
+        record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_317: usize = 1;
-const IN_317: usize = 1;
-const OUT_317: usize = 1;
-fn aiur_fn_317(
-  inp: [G; IN_317],
+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_317], ExecError> {
+) -> Result<[G; OUT_304], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -29073,23 +28061,23 @@ fn aiur_fn_317(
     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_315] = { let __args: [G; IN_315] = [__v_0, __v_13]; 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_13]; 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_14: G = __r_arr[0];
-    let __ret: [G; OUT_317] = [__v_14];
-    record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_304] = [__v_14];
+    record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_318: usize = 2;
-const IN_318: usize = 2;
-const OUT_318: usize = 2;
-fn aiur_fn_318(
-  inp: [G; IN_318],
+const INPUT_SIZE_305: usize = 2;
+const IN_305: usize = 2;
+const OUT_305: usize = 2;
+fn aiur_fn_305(
+  inp: [G; IN_305],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_318], 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];
@@ -29097,8 +28085,8 @@ fn aiur_fn_318(
     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_318] = [__v_0, __v_1];
-        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_305] = [__v_0, __v_1];
+        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -29106,11 +28094,11 @@ fn aiur_fn_318(
         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_318] = { let __args: [G; IN_318] = [__v_5, __v_7]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_318] = [__v_8, __v_9];
-        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_305] = [__v_8, __v_9];
+        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29120,40 +28108,40 @@ fn aiur_fn_318(
   })
 }
 
-const INPUT_SIZE_319: usize = 1;
-const IN_319: usize = 1;
-const OUT_319: usize = 3;
-fn aiur_fn_319(
-  inp: [G; IN_319],
+const INPUT_SIZE_306: usize = 1;
+const IN_306: usize = 1;
+const OUT_306: usize = 3;
+fn aiur_fn_306(
+  inp: [G; IN_306],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_319], ExecError> {
+) -> Result<[G; OUT_306], 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_318] = { let __args: [G; IN_318] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __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_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_318] = { let __args: [G; IN_318] = [__v_3, __v_4]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_4]; 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 __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_319] = [__v_2, __v_5, __v_6];
-    record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_306] = [__v_2, __v_5, __v_6];
+    record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_320: usize = 16;
-const IN_320: usize = 16;
-const OUT_320: usize = 16;
-fn aiur_fn_320(
-  inp: [G; IN_320],
+const INPUT_SIZE_307: usize = 16;
+const IN_307: usize = 16;
+const OUT_307: usize = 16;
+fn aiur_fn_307(
+  inp: [G; IN_307],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_320], 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];
@@ -29284,7 +28272,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -29307,7 +28295,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_148: G = __r_arr[0];
     let __v_149: G = __r_arr[1];
     let __v_150: G = __r_arr[2];
@@ -29330,7 +28318,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_167: G = __r_arr[0];
     let __v_168: G = __r_arr[1];
     let __v_169: G = __r_arr[2];
@@ -29353,7 +28341,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_186: G = __r_arr[0];
     let __v_187: G = __r_arr[1];
     let __v_188: G = __r_arr[2];
@@ -29376,7 +28364,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_205: G = __r_arr[0];
     let __v_206: G = __r_arr[1];
     let __v_207: G = __r_arr[2];
@@ -29399,7 +28387,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_224: G = __r_arr[0];
     let __v_225: G = __r_arr[1];
     let __v_226: G = __r_arr[2];
@@ -29422,7 +28410,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_243: G = __r_arr[0];
     let __v_244: G = __r_arr[1];
     let __v_245: G = __r_arr[2];
@@ -29445,7 +28433,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_262: G = __r_arr[0];
     let __v_263: G = __r_arr[1];
     let __v_264: G = __r_arr[2];
@@ -29468,7 +28456,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_281: G = __r_arr[0];
     let __v_282: G = __r_arr[1];
     let __v_283: G = __r_arr[2];
@@ -29491,7 +28479,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_300: G = __r_arr[0];
     let __v_301: G = __r_arr[1];
     let __v_302: G = __r_arr[2];
@@ -29514,7 +28502,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_319: G = __r_arr[0];
     let __v_320: G = __r_arr[1];
     let __v_321: G = __r_arr[2];
@@ -29537,7 +28525,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_338: G = __r_arr[0];
     let __v_339: G = __r_arr[1];
     let __v_340: G = __r_arr[2];
@@ -29560,7 +28548,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_357: G = __r_arr[0];
     let __v_358: G = __r_arr[1];
     let __v_359: G = __r_arr[2];
@@ -29583,7 +28571,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_376: G = __r_arr[0];
     let __v_377: G = __r_arr[1];
     let __v_378: G = __r_arr[2];
@@ -29606,7 +28594,7 @@ fn aiur_fn_320(
     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_319] = { let __args: [G; IN_319] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { 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_395: G = __r_arr[0];
     let __v_396: G = __r_arr[1];
     let __v_397: G = __r_arr[2];
@@ -29628,21 +28616,21 @@ fn aiur_fn_320(
     if (__v_388 != __v_412) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64() });
     }
-    let __ret: [G; OUT_320] = [__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[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_307] = [__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[307].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 = 1;
-fn aiur_fn_321(
-  inp: [G; IN_321],
+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_321], 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];
@@ -29650,23 +28638,23 @@ fn aiur_fn_321(
     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_322] = { let __args: [G; IN_322] = [__v_0, __v_1, __v_4, __v_5]; 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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_1, __v_4, __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 __ret: [G; OUT_321] = [__v_6];
-    record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_308] = [__v_6];
+    record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_322: usize = 4;
-const IN_322: usize = 4;
-const OUT_322: usize = 1;
-fn aiur_fn_322(
-  inp: [G; IN_322],
+const INPUT_SIZE_309: usize = 4;
+const IN_309: usize = 4;
+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_322], 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];
@@ -29685,8 +28673,8 @@ fn aiur_fn_322(
     let __v_13: G = __loaded[9];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_322] = [__v_2];
-        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_309] = [__v_2];
+        record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -29701,18 +28689,18 @@ fn aiur_fn_322(
         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_323] = { let __args: [G; IN_323] = [__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[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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__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[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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_25, __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 __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_25, __v_3]; 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_2, __v_26]; 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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2, __v_26]; 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_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_322] = { let __args: [G; IN_322] = [__v_13, __v_1, __v_27, __v_29]; 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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_13, __v_1, __v_27, __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 __ret: [G; OUT_322] = [__v_30];
-        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_309] = [__v_30];
+        record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29722,15 +28710,15 @@ fn aiur_fn_322(
   })
 }
 
-const INPUT_SIZE_323: usize = 18;
-const IN_323: usize = 18;
-const OUT_323: usize = 1;
-fn aiur_fn_323(
-  inp: [G; IN_323],
+const INPUT_SIZE_310: usize = 18;
+const IN_310: usize = 18;
+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_323], 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];
@@ -29767,15 +28755,15 @@ fn aiur_fn_323(
         let __v_28: G = __r_arr[0];
         match __v_28.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_323] = [__v_17];
-            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_310] = [__v_17];
+            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__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[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 __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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[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 __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_323] = [__v_29];
-            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_310] = [__v_29];
+            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -29784,7 +28772,7 @@ fn aiur_fn_323(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__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[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 __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__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[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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -29801,7 +28789,7 @@ fn aiur_fn_323(
         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_11] = { let __args: [G; IN_11] = [__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[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_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];
@@ -29818,7 +28806,7 @@ fn aiur_fn_323(
         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_11] = { let __args: [G; IN_11] = [__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[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_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];
@@ -29828,12 +28816,12 @@ fn aiur_fn_323(
         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_801] = { let __args: [G; IN_801] = [__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[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 __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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[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 __v_69: G = __r_arr[0];
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__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[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 __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__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[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_70: G = __r_arr[0];
-        let __ret: [G; OUT_323] = [__v_70];
-        record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_310] = [__v_70];
+        record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29843,22 +28831,22 @@ fn aiur_fn_323(
   })
 }
 
-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_311: usize = 2;
+const IN_311: usize = 2;
+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_324], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_324] = [__v_0];
-        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_311] = [__v_0];
+        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29874,28 +28862,28 @@ fn aiur_fn_324(
         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_324] = { let __args: [G; IN_324] = [__v_11, __v_13]; 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 __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_11, __v_13]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_324] = [__v_14];
-        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_311] = [__v_14];
+        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_325: usize = 1;
-const IN_325: usize = 1;
-const OUT_325: usize = 1;
-fn aiur_fn_325(
-  inp: [G; IN_325],
+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_325], ExecError> {
+) -> Result<[G; OUT_312], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; 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 __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_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];
@@ -29911,65 +28899,65 @@ fn aiur_fn_325(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_325] = [__v_12];
-        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_12];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_325] = [__v_12];
-        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_12];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_326: usize = 2;
-const IN_326: usize = 2;
-const OUT_326: usize = 2;
-fn aiur_fn_326(
-  inp: [G; IN_326],
+const INPUT_SIZE_313: usize = 2;
+const IN_313: usize = 2;
+const OUT_313: usize = 2;
+fn aiur_fn_313(
+  inp: [G; IN_313],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_326], 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 __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_321] = { let __args: [G; IN_321] = [__v_2, __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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_2, __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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_3]; 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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_3]; 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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; 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 __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_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_325] = { let __args: [G; IN_325] = [__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 __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_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_326] = [__v_2, __v_3];
-        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_313] = [__v_2, __v_3];
+        record.function_queries[313].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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_3]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __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 __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_9, __v_1]; 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_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_326] = [__v_2, __v_3];
-        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_313] = [__v_2, __v_3];
+        record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29979,75 +28967,75 @@ fn aiur_fn_326(
   })
 }
 
-const INPUT_SIZE_327: usize = 2;
-const IN_327: usize = 2;
-const OUT_327: usize = 1;
-fn aiur_fn_327(
-  inp: [G; IN_327],
+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_327], 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; 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 __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 __ret: [G; OUT_327] = [__v_2];
-    record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_314] = [__v_2];
+    record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_328: usize = 2;
-const IN_328: usize = 2;
-const OUT_328: usize = 1;
-fn aiur_fn_328(
-  inp: [G; IN_328],
+const INPUT_SIZE_315: usize = 2;
+const IN_315: usize = 2;
+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_328], ExecError> {
+) -> 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; 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 __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 __ret: [G; OUT_328] = [__v_3];
-    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_315] = [__v_3];
+    record.function_queries[315].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],
+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_329], 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 __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__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 __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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_329] = [__v_0];
-        record.function_queries[329].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 __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_1]; 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_3]; 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 __ret: [G; OUT_329] = [__v_4];
-        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_316] = [__v_4];
+        record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30057,19 +29045,19 @@ fn aiur_fn_329(
   })
 }
 
-const INPUT_SIZE_330: usize = 2;
-const IN_330: usize = 2;
-const OUT_330: usize = 1;
-fn aiur_fn_330(
-  inp: [G; IN_330],
+const INPUT_SIZE_317: usize = 2;
+const IN_317: usize = 2;
+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_330], 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];
-    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__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 __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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -30086,8 +29074,8 @@ fn aiur_fn_330(
         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_330] = [__v_15];
-        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_15];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30104,30 +29092,30 @@ fn aiur_fn_330(
         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_326] = { let __args: [G; IN_326] = [__v_1, __v_15]; 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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_15]; 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_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
-        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_0]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_0]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_18]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_18]; 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_16]; 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_19, __v_20]; 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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_19, __v_20]; 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_17]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_17]; 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_22: G = __r_arr[0];
         match __v_22.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_330] = [__v_21];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_317] = [__v_21];
+            record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_21]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_21]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_330] = [__v_23];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_317] = [__v_23];
+            record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30142,15 +29130,15 @@ fn aiur_fn_330(
   })
 }
 
-const INPUT_SIZE_331: usize = 16;
-const IN_331: usize = 16;
-const OUT_331: usize = 8;
-fn aiur_fn_331(
-  inp: [G; IN_331],
+const INPUT_SIZE_318: usize = 16;
+const IN_318: usize = 16;
+const OUT_318: usize = 8;
+fn aiur_fn_318(
+  inp: [G; IN_318],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_331], 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];
@@ -30176,21 +29164,21 @@ fn aiur_fn_331(
     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_331] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_318] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_332: usize = 16;
-const IN_332: usize = 16;
-const OUT_332: usize = 8;
-fn aiur_fn_332(
-  inp: [G; IN_332],
+const INPUT_SIZE_319: usize = 16;
+const IN_319: usize = 16;
+const OUT_319: usize = 8;
+fn aiur_fn_319(
+  inp: [G; IN_319],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_332], 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];
@@ -30216,21 +29204,21 @@ fn aiur_fn_332(
     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_332] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_319] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_333: usize = 16;
-const IN_333: usize = 16;
-const OUT_333: usize = 8;
-fn aiur_fn_333(
-  inp: [G; IN_333],
+const INPUT_SIZE_320: usize = 16;
+const IN_320: usize = 16;
+const OUT_320: usize = 8;
+fn aiur_fn_320(
+  inp: [G; IN_320],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_333], 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];
@@ -30256,21 +29244,21 @@ fn aiur_fn_333(
     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_333] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_320] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_334: usize = 2;
-const IN_334: usize = 2;
-const OUT_334: usize = 1;
-fn aiur_fn_334(
-  inp: [G; IN_334],
+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_334], 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];
@@ -30290,8 +29278,8 @@ fn aiur_fn_334(
         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_334] = [__v_14];
-        record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_321] = [__v_14];
+        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30311,13 +29299,13 @@ fn aiur_fn_334(
             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_334] = [__v_24];
-            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_321] = [__v_24];
+            record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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[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 __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__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[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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -30326,11 +29314,11 @@ fn aiur_fn_334(
             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_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; 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 __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_11, __v_21]; 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_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_334] = [__v_32];
-            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_321] = [__v_32];
+            record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30345,15 +29333,15 @@ fn aiur_fn_334(
   })
 }
 
-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_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_335], ExecError> {
+) -> 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];
@@ -30370,8 +29358,8 @@ fn aiur_fn_335(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_335] = [__v_1];
-        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_322] = [__v_1];
+        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30388,13 +29376,13 @@ fn aiur_fn_335(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_335] = [__v_0];
-            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_322] = [__v_0];
+            record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__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[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 __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__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[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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -30403,11 +29391,11 @@ fn aiur_fn_335(
             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_335] = { let __args: [G; IN_335] = [__v_11, __v_21]; 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 __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_11, __v_21]; 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_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_335] = [__v_32];
-            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_322] = [__v_32];
+            record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30422,15 +29410,15 @@ fn aiur_fn_335(
   })
 }
 
-const INPUT_SIZE_336: usize = 2;
-const IN_336: usize = 2;
-const OUT_336: usize = 1;
-fn aiur_fn_336(
-  inp: [G; IN_336],
+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_336], 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];
@@ -30447,8 +29435,8 @@ fn aiur_fn_336(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_336] = [__v_1];
-        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_323] = [__v_1];
+        record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30465,13 +29453,13 @@ fn aiur_fn_336(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_336] = [__v_0];
-            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_323] = [__v_0];
+            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__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[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 __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__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[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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -30480,11 +29468,11 @@ fn aiur_fn_336(
             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_336] = { let __args: [G; IN_336] = [__v_11, __v_21]; 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 __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_11, __v_21]; 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_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_336] = [__v_32];
-            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_323] = [__v_32];
+            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30499,15 +29487,15 @@ fn aiur_fn_336(
   })
 }
 
-const INPUT_SIZE_337: usize = 2;
-const IN_337: usize = 2;
-const OUT_337: usize = 1;
-fn aiur_fn_337(
-  inp: [G; IN_337],
+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_337], 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];
@@ -30524,25 +29512,25 @@ fn aiur_fn_337(
     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_330] = { let __args: [G; IN_330] = [__v_14, __v_1]; 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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_14, __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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_15]; 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_337] = [__v_16];
-    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_324] = [__v_16];
+    record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_338: usize = 2;
-const IN_338: usize = 2;
-const OUT_338: usize = 1;
-fn aiur_fn_338(
-  inp: [G; IN_338],
+const INPUT_SIZE_325: usize = 2;
+const IN_325: usize = 2;
+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_338], 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];
@@ -30559,25 +29547,25 @@ fn aiur_fn_338(
     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_330] = { let __args: [G; IN_330] = [__v_14, __v_1]; 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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_14, __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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_15]; 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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_15]; 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_338] = [__v_16];
-    record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_325] = [__v_16];
+    record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_339: usize = 3;
-const IN_339: usize = 3;
-const OUT_339: usize = 2;
-fn aiur_fn_339(
-  inp: [G; IN_339],
+const INPUT_SIZE_326: usize = 3;
+const IN_326: usize = 3;
+const OUT_326: usize = 2;
+fn aiur_fn_326(
+  inp: [G; IN_326],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_339], 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];
@@ -30590,28 +29578,28 @@ fn aiur_fn_339(
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_339] = [__v_6, __v_7];
-        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_6, __v_7];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_4]; 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 __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_339] = [__v_7, __v_2];
-            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_326] = [__v_7, __v_2];
+            record.function_queries[326].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_339] = { let __args: [G; IN_339] = [__v_0, __v_5, __v_8]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_5, __v_8]; 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_339] = [__v_9, __v_10];
-            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_326] = [__v_9, __v_10];
+            record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30626,15 +29614,15 @@ fn aiur_fn_339(
   })
 }
 
-const INPUT_SIZE_340: usize = 3;
-const IN_340: usize = 3;
-const OUT_340: usize = 1;
-fn aiur_fn_340(
-  inp: [G; IN_340],
+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_340], 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];
@@ -30658,16 +29646,16 @@ fn aiur_fn_340(
         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_13, __v_1, __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_340] = [__v_18];
-        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_327] = [__v_18];
+        record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0]; 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 __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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_13]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_13]; 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_344] = { let __args: [G; IN_344] = [__v_14]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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(2);
         let __v_17: G = G::from_u64(1);
@@ -30678,8 +29666,8 @@ fn aiur_fn_340(
         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 __ret: [G; OUT_340] = [__v_24];
-        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_327] = [__v_24];
+        record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30689,15 +29677,15 @@ fn aiur_fn_340(
   })
 }
 
-const INPUT_SIZE_341: usize = 2;
-const IN_341: usize = 2;
-const OUT_341: usize = 1;
-fn aiur_fn_341(
-  inp: [G; IN_341],
+const INPUT_SIZE_328: usize = 2;
+const IN_328: usize = 2;
+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_341], 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];
@@ -30710,67 +29698,67 @@ fn aiur_fn_341(
       7u64 => {
         match __v_3.as_canonical_u64() {
           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 __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_6: G = __r_arr[0];
             let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_1, __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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_6, __v_1, __v_7]; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            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 __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_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_10, __v_1, __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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_10, __v_1, __v_11]; 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_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 __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_9, __v_13]; 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 __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_9, __v_13]; 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_14: G = __r_arr[0];
-                    let __ret: [G; OUT_341] = [__v_14];
-                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_328] = [__v_14];
+                    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __ret: [G; OUT_341] = [__v_0];
-                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_328] = [__v_0];
+                    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_341] = [__v_0];
-                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_328] = [__v_0];
+                record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_341] = [__v_0];
-            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_328] = [__v_0];
+            record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_341] = [__v_0];
-        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_328] = [__v_0];
+        record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_342: usize = 2;
-const IN_342: usize = 2;
-const OUT_342: usize = 2;
-fn aiur_fn_342(
-  inp: [G; IN_342],
+const INPUT_SIZE_329: usize = 2;
+const IN_329: usize = 2;
+const OUT_329: usize = 2;
+fn aiur_fn_329(
+  inp: [G; IN_329],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_342], 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];
@@ -30784,8 +29772,8 @@ fn aiur_fn_342(
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_342] = [__v_6, __v_4];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_6, __v_4];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30793,18 +29781,18 @@ fn aiur_fn_342(
             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_342] = [__v_6, __v_9];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_6, __v_9];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_3]; 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 __v_6: G = __r_arr[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 __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_130] = { let __args: [G; IN_130] = [__v_6, __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 __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 => {
@@ -30812,8 +29800,8 @@ fn aiur_fn_342(
             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_342] = [__v_9, __v_12];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_9, __v_12];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -30821,8 +29809,8 @@ fn aiur_fn_342(
             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_342] = [__v_9, __v_12];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_9, __v_12];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30831,11 +29819,11 @@ fn aiur_fn_342(
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_4, __v_1]; 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 __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_4, __v_1]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __ret: [G; OUT_342] = [__v_6, __v_7];
-        record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_329] = [__v_6, __v_7];
+        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30843,23 +29831,23 @@ fn aiur_fn_342(
         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_342] = [__v_6, __v_9];
-        record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_329] = [__v_6, __v_9];
+        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_343: usize = 3;
-const IN_343: usize = 3;
-const OUT_343: usize = 2;
-fn aiur_fn_343(
-  inp: [G; IN_343],
+const INPUT_SIZE_330: usize = 3;
+const IN_330: usize = 3;
+const OUT_330: usize = 2;
+fn aiur_fn_330(
+  inp: [G; IN_330],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_343], 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];
@@ -30871,24 +29859,24 @@ fn aiur_fn_343(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_4]; 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 __v_7: 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 __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_7, __v_8]; 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 __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() {
           1u64 => {
-            let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__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 __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_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_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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_11]; 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_13: G = __r_arr[0];
-                let __ret: [G; OUT_343] = [__v_12, __v_13];
-                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_330] = [__v_12, __v_13];
+                record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -30896,8 +29884,8 @@ fn aiur_fn_343(
                 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_343] = [__v_12, __v_15];
-                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_330] = [__v_12, __v_15];
+                record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -30907,8 +29895,8 @@ fn aiur_fn_343(
             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_343] = [__v_10, __v_13];
-            record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_330] = [__v_10, __v_13];
+            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30921,217 +29909,217 @@ fn aiur_fn_343(
         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_343] = [__v_7, __v_10];
-        record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_7, __v_10];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_331: usize = 1;
+const IN_331: usize = 1;
+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_344], ExecError> {
+) -> Result<[G; OUT_331], 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_344] = [__v_4];
-    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_331] = [__v_4];
+    record.function_queries[331].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_332: usize = 1;
+const IN_332: usize = 1;
+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_345], ExecError> {
+) -> Result<[G; OUT_332], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[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 __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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; 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 __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 __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 __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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __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 __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];
-    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 __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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_5]; 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 __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_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 __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 = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __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 __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_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 __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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_9]; 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 __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_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 __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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_11]; 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 __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_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 __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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_13]; 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 __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_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 __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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_15]; 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 __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_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 __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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_17]; 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 __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 __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 __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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_19]; 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 __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];
-    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 __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_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_21]; 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 __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];
-    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 __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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_23]; 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 __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];
-    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 __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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_25]; 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 __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];
-    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 __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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_27]; 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 __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];
-    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 __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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_29]; 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 __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];
-    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 __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_31: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_31]; 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 __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];
-    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 __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_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_33]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_33]; 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_34: 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 __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_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_35]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __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];
-    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 __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_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_37]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_37]; 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_38: G = __r_arr[0];
-    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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 __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_39: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_39]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __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];
-    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = []; 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 __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_41: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_41]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_41]; 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_42: G = __r_arr[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 __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_43: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_43]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __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];
-    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 __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_45: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_45]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_45]; 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_46: G = __r_arr[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 __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_47: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_47]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_47]; 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_48: G = __r_arr[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 __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_49: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_49]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_49]; 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_50: G = __r_arr[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 __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_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_51]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_51]; 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_52: G = __r_arr[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 __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_53: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_53]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_53]; 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_54: G = __r_arr[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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = []; 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_55: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_55]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_55]; 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_56: 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 __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_57: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_57]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __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];
-    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 __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_59: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_59]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_59]; 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_60: 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 __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_61: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_61]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_61]; 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_62: 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 __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_63: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_63]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_63]; 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_64: 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 __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_65: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_65]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_65]; 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_66: G = __r_arr[0];
-    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 __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_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_67]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_67]; 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_68: 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 __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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_69]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __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 __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 __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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_71]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_71]; 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_72: 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 __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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_73]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_73]; 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_74: 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 __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_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_75]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_75]; 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_76: G = __r_arr[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 __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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_77]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_77]; 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_78: G = __r_arr[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 __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_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_79]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_79]; 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_80: 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 __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_81: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_81]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_81]; 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_82: G = __r_arr[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 __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_83: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_83]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_83]; 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_84: 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 __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_85: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_85]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_85]; 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_86: G = __r_arr[0];
     let __v_87: G = (__v_84 + __v_86);
     let __v_88: G = (__v_82 + __v_87);
@@ -31175,36 +30163,36 @@ fn aiur_fn_345(
     let __v_126: G = (__v_6 + __v_125);
     let __v_127: G = (__v_4 + __v_126);
     let __v_128: G = (__v_2 + __v_127);
-    let __ret: [G; OUT_345] = [__v_128];
-    record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_332] = [__v_128];
+    record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_333: usize = 5;
+const IN_333: usize = 5;
+const OUT_333: usize = 2;
+fn aiur_fn_333(
+  inp: [G; IN_333],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_346], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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_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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_6]; 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 __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_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 __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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_8]; 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 __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() {
       1u64 => {
@@ -31217,33 +30205,33 @@ fn aiur_fn_346(
             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 __ret: [G; OUT_333] = [__v_12, __v_16];
+            record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_12]; 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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_13, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14, __v_4]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_14, __v_4]; 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_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_799] = { let __args: [G; IN_799] = [__v_1, __v_17]; 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_769] = { let __args: [G; IN_769] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_16]; 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_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_20]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_18]; 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_400] = { let __args: [G; IN_400] = [__v_21, __v_18]; 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_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));
+                let __ret: [G; OUT_333] = [__v_19, __v_22];
+                record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -31252,8 +30240,8 @@ fn aiur_fn_346(
                 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 __ret: [G; OUT_333] = [__v_17, __v_21];
+                record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -31275,33 +30263,33 @@ fn aiur_fn_346(
                 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 __ret: [G; OUT_333] = [__v_12, __v_16];
+                record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_12]; 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 __v_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_13, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14, __v_4]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_14, __v_4]; 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_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_799] = { let __args: [G; IN_799] = [__v_1, __v_17]; 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_769] = { let __args: [G; IN_769] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_317] = { let __args: [G; IN_317] = [__v_16]; 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 __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_344] = { let __args: [G; IN_344] = [__v_20]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_18]; 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_400] = { let __args: [G; IN_400] = [__v_21, __v_18]; 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_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));
+                    let __ret: [G; OUT_333] = [__v_19, __v_22];
+                    record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -31310,8 +30298,8 @@ fn aiur_fn_346(
                     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 __ret: [G; OUT_333] = [__v_17, __v_21];
+                    record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -31322,11 +30310,11 @@ fn aiur_fn_346(
             }
           },
           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 __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1, __v_5, __v_2, __v_3, __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_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));
+            let __ret: [G; OUT_333] = [__v_10, __v_11];
+            record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -31341,15 +30329,15 @@ fn aiur_fn_346(
   })
 }
 
-const INPUT_SIZE_347: usize = 6;
-const IN_347: usize = 6;
-const OUT_347: usize = 2;
-fn aiur_fn_347(
-  inp: [G; IN_347],
+const INPUT_SIZE_334: usize = 6;
+const IN_334: usize = 6;
+const OUT_334: usize = 2;
+fn aiur_fn_334(
+  inp: [G; IN_334],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_347], 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];
@@ -31366,44 +30354,44 @@ fn aiur_fn_347(
         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));
+        let __ret: [G; OUT_334] = [__v_8, __v_12];
+        record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_8]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_8]; 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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_9, __v_3, __v_4, __v_5]; 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_11]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_11]; 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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_12, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_12, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_10, __v_5]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_10, __v_5]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_13, __v_5]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_13, __v_5]; 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_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_348] = { let __args: [G; IN_348] = [__v_0, __v_15, __v_17, __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 __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_15, __v_17, __v_5]; 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 __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_799] = { let __args: [G; IN_799] = [__v_1, __v_20]; 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_769] = { let __args: [G; IN_769] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_19, __v_21]; 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_400] = { let __args: [G; IN_400] = [__v_19, __v_21]; 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_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));
+                    let __ret: [G; OUT_334] = [__v_22, __v_23];
+                    record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -31412,8 +30400,8 @@ fn aiur_fn_347(
                     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));
+                    let __ret: [G; OUT_334] = [__v_20, __v_24];
+                    record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -31427,8 +30415,8 @@ fn aiur_fn_347(
                 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 __ret: [G; OUT_334] = [__v_18, __v_22];
+                record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -31439,8 +30427,8 @@ fn aiur_fn_347(
             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 __ret: [G; OUT_334] = [__v_18, __v_22];
+            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -31452,265 +30440,265 @@ fn aiur_fn_347(
   })
 }
 
-const INPUT_SIZE_348: usize = 4;
-const IN_348: usize = 4;
-const OUT_348: usize = 2;
-fn aiur_fn_348(
-  inp: [G; IN_348],
+const INPUT_SIZE_335: usize = 4;
+const IN_335: usize = 4;
+const OUT_335: usize = 2;
+fn aiur_fn_335(
+  inp: [G; IN_335],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_348], 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 __v_3: G = inp[3];
-    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 __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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_4]; 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 __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_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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_8]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_8]; 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 __ret: [G; OUT_348] = [__v_6, __v_9];
-        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_335] = [__v_6, __v_9];
+        record.function_queries[335].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 __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_6]; 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 __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_315] = { let __args: [G; IN_315] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_9]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_9]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_10]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __ret: [G; OUT_348] = [__v_8, __v_11];
-            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_335] = [__v_8, __v_11];
+            record.function_queries[335].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 __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_8]; 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 __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() {
               1u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_11]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_11]; 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_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_12]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __ret: [G; OUT_348] = [__v_10, __v_13];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_335] = [__v_10, __v_13];
+                record.function_queries[335].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 __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_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_10]; 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 __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_327] = { let __args: [G; IN_327] = [__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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2]; 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_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_13]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_13]; 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_344] = { let __args: [G; IN_344] = [__v_14]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __ret: [G; OUT_348] = [__v_12, __v_15];
-                    record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_335] = [__v_12, __v_15];
+                    record.function_queries[335].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 __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_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_12]; 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 __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_328] = { let __args: [G; IN_328] = [__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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_2]; 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_15: G = __r_arr[0];
-                        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_15]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_15]; 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_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_16]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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_348] = [__v_14, __v_17];
-                        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_335] = [__v_14, __v_17];
+                        record.function_queries[335].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 __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_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_14]; 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 __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_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 __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_17: G = __r_arr[0];
-                            let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_17]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_17]; 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_18: G = __r_arr[0];
-                            let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_18]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_18]; 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_19: G = __r_arr[0];
-                            let __ret: [G; OUT_348] = [__v_16, __v_19];
-                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_335] = [__v_16, __v_19];
+                            record.function_queries[335].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 __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_16: G = __r_arr[0];
-                            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_16]; 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 __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_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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__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_19: G = __r_arr[0];
-                                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_19]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_19]; 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_20: G = __r_arr[0];
-                                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_20]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __ret: [G; OUT_348] = [__v_18, __v_21];
-                                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_335] = [__v_18, __v_21];
+                                record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                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 __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_18: G = __r_arr[0];
-                                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_18]; 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 __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_334] = { let __args: [G; IN_334] = [__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 __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1, __v_2]; 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_21: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_21]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_21]; 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_22: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_22]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_22]; 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_23: G = __r_arr[0];
-                                    let __ret: [G; OUT_348] = [__v_20, __v_23];
-                                    record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_335] = [__v_20, __v_23];
+                                    record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    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 __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_20: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __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 __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_335] = { let __args: [G; IN_335] = [__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 __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_23: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_23]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_23]; 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_24: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_24]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_24]; 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 __ret: [G; OUT_348] = [__v_22, __v_25];
-                                        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_335] = [__v_22, __v_25];
+                                        record.function_queries[335].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 __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_22: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_22]; 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 __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_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 __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_25: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_25]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_25]; 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_26: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_26]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_26]; 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_27: G = __r_arr[0];
-                                            let __ret: [G; OUT_348] = [__v_24, __v_27];
-                                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_335] = [__v_24, __v_27];
+                                            record.function_queries[335].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 __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_24: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_24]; 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 __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_337] = { let __args: [G; IN_337] = [__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 __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_27: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_27]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_27]; 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_28: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_28]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_28]; 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_29: G = __r_arr[0];
-                                                let __ret: [G; OUT_348] = [__v_26, __v_29];
-                                                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_335] = [__v_26, __v_29];
+                                                record.function_queries[335].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 __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_26: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_26]; 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 __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_338] = { let __args: [G; IN_338] = [__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 __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_29: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_29]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_29]; 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_30: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_30]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_30]; 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 __ret: [G; OUT_348] = [__v_28, __v_31];
-                                                    record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_335] = [__v_28, __v_31];
+                                                    record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   0u64 => {
-                                                    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 __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_28: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_28]; 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 __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_237] = { let __args: [G; IN_237] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_1, __v_2]; 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_31: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_31, __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 __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_31, __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_32: G = __r_arr[0];
-                                                        let __ret: [G; OUT_348] = [__v_30, __v_32];
-                                                        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        let __ret: [G; OUT_335] = [__v_30, __v_32];
+                                                        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                         return Ok(__ret);
                                                       },
                                                       0u64 => {
-                                                        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 __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_30: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_30]; 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 __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_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 __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_1, __v_2]; 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_33: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_33, __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 __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_33, __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_34: G = __r_arr[0];
-                                                            let __ret: [G; OUT_348] = [__v_32, __v_34];
-                                                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_335] = [__v_32, __v_34];
+                                                            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                           0u64 => {
@@ -31719,8 +30707,8 @@ fn aiur_fn_348(
                                                             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_348] = [__v_32, __v_36];
-                                                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_335] = [__v_32, __v_36];
+                                                            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
@@ -31795,26 +30783,26 @@ fn aiur_fn_348(
   })
 }
 
-const INPUT_SIZE_349: usize = 2;
-const IN_349: usize = 2;
-const OUT_349: usize = 1;
-fn aiur_fn_349(
-  inp: [G; IN_349],
+const INPUT_SIZE_336: usize = 2;
+const IN_336: usize = 2;
+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_349], 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = []; 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 __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];
     break '__mc_0 [__v_2];
   },
   _ => {
-    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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 __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_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
@@ -31822,7 +30810,7 @@ fn aiur_fn_349(
  };
     let __v_2: G = __mc_out___mc_0[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_1, __v_3]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -31833,8 +30821,8 @@ fn aiur_fn_349(
         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_349] = [__v_11];
-        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_336] = [__v_11];
+        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -31847,8 +30835,8 @@ fn aiur_fn_349(
             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_349] = [__v_12];
-            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_336] = [__v_12];
+            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -31869,8 +30857,8 @@ fn aiur_fn_349(
             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_349] = [__v_22];
-            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_336] = [__v_22];
+            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -31882,71 +30870,21 @@ fn aiur_fn_349(
   })
 }
 
-const INPUT_SIZE_350: usize = 1;
-const IN_350: usize = 1;
-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_350], 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 __ret: [G; OUT_350] = [__v_11];
-        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_11: G = G::from_u64(256);
-        let __v_12: G = (__v_11 * __v_3);
-        let __v_13: G = G::from_u64(65536);
-        let __v_14: G = (__v_13 * __v_4);
-        let __v_15: G = G::from_u64(16777216);
-        let __v_16: G = (__v_15 * __v_5);
-        let __v_17: G = (__v_14 + __v_16);
-        let __v_18: G = (__v_12 + __v_17);
-        let __v_19: G = (__v_2 + __v_18);
-        let __ret: [G; OUT_350] = [__v_19];
-        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_351: usize = 4;
-const IN_351: usize = 4;
-const OUT_351: usize = 2;
-fn aiur_fn_351(
-  inp: [G; IN_351],
+const INPUT_SIZE_337: usize = 4;
+const IN_337: usize = 4;
+const OUT_337: usize = 2;
+fn aiur_fn_337(
+  inp: [G; IN_337],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_351], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 };
@@ -31957,20 +30895,20 @@ fn aiur_fn_351(
         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_351] = [__v_7, __v_11];
-        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_7, __v_11];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_7]; 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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_9]; 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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_10, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_11, __v_3]; 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 __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_3]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -31981,14 +30919,14 @@ fn aiur_fn_351(
             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_351] = [__v_15, __v_19];
-            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_337] = [__v_15, __v_19];
+            record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_14, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_14, __v_1, __v_2, __v_3]; 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_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_15, __v_3]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_15, __v_3]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             match __v_16.as_canonical_u64() {
@@ -31998,14 +30936,14 @@ fn aiur_fn_351(
                 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_351] = [__v_18, __v_22];
-                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_337] = [__v_18, __v_22];
+                record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_13, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_13, __v_1, __v_2, __v_3]; 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_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_18, __v_3]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_18, __v_3]; 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_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
                 match __v_19.as_canonical_u64() {
@@ -32015,8 +30953,8 @@ fn aiur_fn_351(
                     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_351] = [__v_21, __v_25];
-                    record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_337] = [__v_21, __v_25];
+                    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -32033,15 +30971,15 @@ fn aiur_fn_351(
                     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_330] = { let __args: [G; IN_330] = [__v_33, __v_20]; 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 __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_33, __v_20]; 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_34: G = __r_arr[0];
-                    let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_17, __v_34]; 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 __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_17, __v_34]; 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_35: G = __r_arr[0];
                     let __v_36: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_35]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_35]; 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_37: G = __r_arr[0];
-                    let __ret: [G; OUT_351] = [__v_36, __v_37];
-                    record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_337] = [__v_36, __v_37];
+                    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -32066,19 +31004,19 @@ fn aiur_fn_351(
   })
 }
 
-const INPUT_SIZE_352: usize = 2;
-const IN_352: usize = 2;
-const OUT_352: usize = 3;
-fn aiur_fn_352(
-  inp: [G; IN_352],
+const INPUT_SIZE_338: usize = 2;
+const IN_338: usize = 2;
+const OUT_338: usize = 3;
+fn aiur_fn_338(
+  inp: [G; IN_338],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_352], 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];
-    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 __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 };
@@ -32088,15 +31026,15 @@ fn aiur_fn_352(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[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 __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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8, __v_9]; 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 __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_200] = { let __args: [G; IN_200] = [__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 __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);
@@ -32104,13 +31042,13 @@ fn aiur_fn_352(
               0u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_15]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_15]; 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 __v_16: G = __r_arr[0];
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_17]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_17]; 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 __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_352] = [__v_14, __v_16, __v_18];
-                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_338] = [__v_14, __v_16, __v_18];
+                record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32123,8 +31061,8 @@ fn aiur_fn_352(
                 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_14, __v_18, __v_22];
-                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_338] = [__v_14, __v_18, __v_22];
+                record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -32163,7 +31101,7 @@ fn aiur_fn_352(
             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_130] = { let __args: [G; IN_130] = [__v_8, __v_43]; 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 __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 => {
@@ -32176,12 +31114,12 @@ fn aiur_fn_352(
                 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_352] = [__v_45, __v_49, __v_53];
-                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_338] = [__v_45, __v_49, __v_53];
+                record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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 };
@@ -32196,15 +31134,15 @@ fn aiur_fn_352(
                     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_352] = [__v_48, __v_52, __v_56];
-                    record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_338] = [__v_48, __v_52, __v_56];
+                    record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_48]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_48]; 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 __v_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_49]; 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 __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 };
@@ -32214,11 +31152,11 @@ fn aiur_fn_352(
                     let __v_55: G = __loaded[3];
                     match __v_52.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_53]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_53]; 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 __v_56: G = __r_arr[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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = []; 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_57: G = __r_arr[0];
-                        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_56, __v_57]; 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 __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 => {
@@ -32231,12 +31169,12 @@ fn aiur_fn_352(
                             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_352] = [__v_59, __v_63, __v_67];
-                            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_338] = [__v_59, __v_63, __v_67];
+                            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_51]; 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 __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);
@@ -32244,13 +31182,13 @@ fn aiur_fn_352(
                               0u64 => {
                                 let __v_62: G = G::from_u64(1);
                                 let __v_63: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_51, __v_63]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_51, __v_63]; 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 __v_64: G = __r_arr[0];
                                 let __v_65: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_65]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_65]; 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 __v_66: G = __r_arr[0];
-                                let __ret: [G; OUT_352] = [__v_62, __v_64, __v_66];
-                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_338] = [__v_62, __v_64, __v_66];
+                                record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32263,8 +31201,8 @@ fn aiur_fn_352(
                                 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_352] = [__v_62, __v_66, __v_70];
-                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_338] = [__v_62, __v_66, __v_70];
+                                record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -32284,8 +31222,8 @@ fn aiur_fn_352(
                         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_352] = [__v_56, __v_60, __v_64];
-                        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_338] = [__v_56, __v_60, __v_64];
+                        record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -32315,29 +31253,29 @@ fn aiur_fn_352(
         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_352] = [__v_8, __v_12, __v_16];
-        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_338] = [__v_8, __v_12, __v_16];
+        record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_353: usize = 4;
-const IN_353: usize = 4;
-const OUT_353: usize = 2;
-fn aiur_fn_353(
-  inp: [G; IN_353],
+const INPUT_SIZE_339: usize = 4;
+const IN_339: usize = 4;
+const OUT_339: usize = 2;
+fn aiur_fn_339(
+  inp: [G; IN_339],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_353], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 };
@@ -32348,24 +31286,24 @@ fn aiur_fn_353(
         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_353] = [__v_7, __v_11];
-        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_339] = [__v_7, __v_11];
+        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_7]; 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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_9]; 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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(2);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_11]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_11]; 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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_8, __v_10, __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 __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_8, __v_10, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_8, __v_12, __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 __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_8, __v_12, __v_1, __v_2, __v_3]; 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_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         match __v_13.as_canonical_u64() {
@@ -32375,8 +31313,8 @@ fn aiur_fn_353(
             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_353] = [__v_17, __v_21];
-            record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_339] = [__v_17, __v_21];
+            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -32387,20 +31325,20 @@ fn aiur_fn_353(
                 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_353] = [__v_17, __v_21];
-                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_339] = [__v_17, __v_21];
+                record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_16, __v_14]; 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 __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_16, __v_14]; 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_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_349] = { let __args: [G; IN_349] = [__v_19, __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 __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_19, __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_21: G = __r_arr[0];
-                let __ret: [G; OUT_353] = [__v_20, __v_21];
-                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_339] = [__v_20, __v_21];
+                record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32420,15 +31358,15 @@ fn aiur_fn_353(
   })
 }
 
-const INPUT_SIZE_354: usize = 5;
-const IN_354: usize = 5;
-const OUT_354: usize = 2;
-fn aiur_fn_354(
-  inp: [G; IN_354],
+const INPUT_SIZE_340: usize = 5;
+const IN_340: usize = 5;
+const OUT_340: usize = 2;
+fn aiur_fn_340(
+  inp: [G; IN_340],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_354], 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];
@@ -32442,7 +31380,7 @@ fn aiur_fn_354(
     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_351] = { let __args: [G; IN_351] = [__v_11, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     match __v_12.as_canonical_u64() {
@@ -32451,8 +31389,8 @@ fn aiur_fn_354(
         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_354] = [__v_14, __v_17];
-        record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_340] = [__v_14, __v_17];
+        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -32466,8 +31404,8 @@ fn aiur_fn_354(
             match __v_15.as_canonical_u64() {
               0u64 => {
                 let __v_18: G = G::from_u64(1);
-                let __ret: [G; OUT_354] = [__v_18, __v_16];
-                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_340] = [__v_18, __v_16];
+                record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32475,8 +31413,8 @@ fn aiur_fn_354(
                 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_354] = [__v_18, __v_21];
-                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_340] = [__v_18, __v_21];
+                record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -32486,8 +31424,8 @@ fn aiur_fn_354(
             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_354] = [__v_18, __v_21];
-            record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_340] = [__v_18, __v_21];
+            record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -32499,60 +31437,60 @@ fn aiur_fn_354(
   })
 }
 
-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_341: usize = 5;
+const IN_341: usize = 5;
+const OUT_341: usize = 2;
+fn aiur_fn_341(
+  inp: [G; IN_341],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_355], 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = []; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_5]; 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 __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_351] = { let __args: [G; IN_351] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_2, __v_3, __v_4]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_355] = [__v_7, __v_8];
-        record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_341] = [__v_7, __v_8];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __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 __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 __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2, __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 __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_2, __v_3, __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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_355] = [__v_9, __v_10];
-            record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_341] = [__v_9, __v_10];
+            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           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 __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_9]; 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 __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_356] = { let __args: [G; IN_356] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
                 let __v_12: G = __r_arr[1];
-                let __ret: [G; OUT_355] = [__v_11, __v_12];
-                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_341] = [__v_11, __v_12];
+                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -32561,8 +31499,8 @@ fn aiur_fn_355(
                 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));
+                let __ret: [G; OUT_341] = [__v_11, __v_15];
+                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32582,21 +31520,21 @@ fn aiur_fn_355(
   })
 }
 
-const INPUT_SIZE_356: usize = 4;
-const IN_356: usize = 4;
-const OUT_356: usize = 2;
-fn aiur_fn_356(
-  inp: [G; IN_356],
+const INPUT_SIZE_342: usize = 4;
+const IN_342: usize = 4;
+const OUT_342: usize = 2;
+fn aiur_fn_342(
+  inp: [G; IN_342],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_356], 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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 };
@@ -32607,15 +31545,15 @@ fn aiur_fn_356(
         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_356] = [__v_7, __v_11];
-        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_342] = [__v_7, __v_11];
+        record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_7]; 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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8]; 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 __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 };
@@ -32625,11 +31563,11 @@ fn aiur_fn_356(
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_12]; 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 __v_15: 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 __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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_15, __v_16]; 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 __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 => {
@@ -32638,12 +31576,12 @@ fn aiur_fn_356(
                 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_356] = [__v_18, __v_22];
-                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_342] = [__v_18, __v_22];
+                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_10]; 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 __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 };
@@ -32654,15 +31592,15 @@ fn aiur_fn_356(
                     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_356] = [__v_21, __v_25];
-                    record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_342] = [__v_21, __v_25];
+                    record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_21: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_10, __v_21]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_10, __v_21]; 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 __v_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_22]; 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 __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 };
@@ -32672,11 +31610,11 @@ fn aiur_fn_356(
                     let __v_28: G = __loaded[3];
                     match __v_25.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_26]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_26]; 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 __v_29: G = __r_arr[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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = []; 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_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_29, __v_30]; 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 __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 => {
@@ -32685,12 +31623,12 @@ fn aiur_fn_356(
                             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_356] = [__v_32, __v_36];
-                            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_342] = [__v_32, __v_36];
+                            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_24]; 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 __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 };
@@ -32701,19 +31639,19 @@ fn aiur_fn_356(
                                 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_356] = [__v_35, __v_39];
-                                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_342] = [__v_35, __v_39];
+                                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_35: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_24, __v_35]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_24, __v_35]; 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 __v_36: G = __r_arr[0];
                                 let __v_37: G = G::from_u64(2);
-                                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_10, __v_37]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_10, __v_37]; 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 __v_38: G = __r_arr[0];
                                 let __v_39: G = G::from_u64(3);
-                                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_10, __v_39]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_10, __v_39]; 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 __v_40: G = __r_arr[0];
                                 let __v_41: G = G::from_u64(0);
                                 let __v_42: G = G::from_u64(0);
@@ -32724,11 +31662,11 @@ fn aiur_fn_356(
                                 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_353] = { let __args: [G; IN_353] = [__v_49, __v_1, __v_2, __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 __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_49, __v_1, __v_2, __v_3]; 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_50: G = __r_arr[0];
                                 let __v_51: G = __r_arr[1];
-                                let __ret: [G; OUT_356] = [__v_50, __v_51];
-                                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_342] = [__v_50, __v_51];
+                                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32747,8 +31685,8 @@ fn aiur_fn_356(
                         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_356] = [__v_29, __v_33];
-                        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_342] = [__v_29, __v_33];
+                        record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -32769,8 +31707,8 @@ fn aiur_fn_356(
             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_356] = [__v_15, __v_19];
-            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_342] = [__v_15, __v_19];
+            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -32782,84 +31720,84 @@ fn aiur_fn_356(
   })
 }
 
-const INPUT_SIZE_357: usize = 5;
-const IN_357: usize = 5;
-const OUT_357: usize = 2;
-fn aiur_fn_357(
-  inp: [G; IN_357],
+const INPUT_SIZE_343: usize = 5;
+const IN_343: usize = 5;
+const OUT_343: usize = 2;
+fn aiur_fn_343(
+  inp: [G; IN_343],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_357], ExecError> {
+) -> Result<[G; OUT_343], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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_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 __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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_5]; 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 __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 __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = []; 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 __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_8: G = __r_arr[0];
-        let __ret: [G; OUT_357] = [__v_7, __v_8];
-        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_343] = [__v_7, __v_8];
+        record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __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 __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 __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_4]; 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 __ret: [G; OUT_357] = [__v_9, __v_10];
-            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_343] = [__v_9, __v_10];
+            record.function_queries[343].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 __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_9]; 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 __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_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 __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __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_11: G = __r_arr[0];
                 let __v_12: G = __r_arr[1];
-                let __ret: [G; OUT_357] = [__v_11, __v_12];
-                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_343] = [__v_11, __v_12];
+                record.function_queries[343].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 __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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_11]; 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 __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 __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 __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_14: G = __r_arr[0];
-                    let __ret: [G; OUT_357] = [__v_13, __v_14];
-                    record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_343] = [__v_13, __v_14];
+                    record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    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 __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_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_13]; 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 __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_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 __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_15: G = __r_arr[0];
-                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_15]; 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 __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() {
@@ -32869,12 +31807,12 @@ fn aiur_fn_357(
                         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 __ret: [G; OUT_343] = [__v_18, __v_22];
+                        record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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 };
@@ -32885,31 +31823,31 @@ fn aiur_fn_357(
                             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 __ret: [G; OUT_343] = [__v_21, __v_25];
+                            record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
                             let __v_21: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_21]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_21]; 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 __v_22: G = __r_arr[0];
-                            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_22, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_22, __v_2, __v_3, __v_4]; 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_23: G = __r_arr[0];
                             match __v_14.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_23, __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 __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_23, __v_4]; 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_24: G = __r_arr[0];
                                 let __v_25: G = __r_arr[1];
-                                let __ret: [G; OUT_357] = [__v_24, __v_25];
-                                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_343] = [__v_24, __v_25];
+                                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_23]; 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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_23]; 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];
-                                let __ret: [G; OUT_357] = [__v_24, __v_25];
-                                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_343] = [__v_24, __v_25];
+                                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32946,15 +31884,15 @@ fn aiur_fn_357(
   })
 }
 
-const INPUT_SIZE_358: usize = 0;
-const IN_358: usize = 0;
-const OUT_358: usize = 1;
-fn aiur_fn_358(
-  inp: [G; IN_358],
+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_358], ExecError> {
+) -> Result<[G; OUT_344], 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);
@@ -32973,21 +31911,21 @@ fn aiur_fn_358(
     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_358] = [__v_16];
-    record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_344] = [__v_16];
+    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_359: usize = 0;
-const IN_359: usize = 0;
-const OUT_359: usize = 1;
-fn aiur_fn_359(
-  inp: [G; IN_359],
+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_359], ExecError> {
+) -> Result<[G; OUT_345], 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);
@@ -33006,25 +31944,25 @@ fn aiur_fn_359(
     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));
+    let __ret: [G; OUT_345] = [__v_16];
+    record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_360: usize = 2;
-const IN_360: usize = 2;
-const OUT_360: usize = 2;
-fn aiur_fn_360(
-  inp: [G; IN_360],
+const INPUT_SIZE_346: usize = 2;
+const IN_346: usize = 2;
+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_360], ExecError> {
+) -> 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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 };
@@ -33035,15 +31973,15 @@ fn aiur_fn_360(
         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_360] = [__v_5, __v_9];
-        record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_346] = [__v_5, __v_9];
+        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(2);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_5]; 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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6]; 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 __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 };
@@ -33053,19 +31991,19 @@ fn aiur_fn_360(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_10]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_10]; 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 __v_13: 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 __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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13, __v_14]; 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 __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_358] = { let __args: [G; IN_358] = []; 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 __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_17: G = __r_arr[0];
-                let __ret: [G; OUT_360] = [__v_16, __v_17];
-                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_346] = [__v_16, __v_17];
+                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -33074,8 +32012,8 @@ fn aiur_fn_360(
                 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_360] = [__v_16, __v_20];
-                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_346] = [__v_16, __v_20];
+                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33089,8 +32027,8 @@ fn aiur_fn_360(
             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_360] = [__v_13, __v_17];
-            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_346] = [__v_13, __v_17];
+            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33102,19 +32040,19 @@ fn aiur_fn_360(
   })
 }
 
-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_347: usize = 2;
+const IN_347: usize = 2;
+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_361], 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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 };
@@ -33125,15 +32063,15 @@ fn aiur_fn_361(
         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));
+        let __ret: [G; OUT_347] = [__v_5, __v_9];
+        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_5]; 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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6]; 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 __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 };
@@ -33143,15 +32081,15 @@ fn aiur_fn_361(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_10]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_10]; 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 __v_13: G = __r_arr[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 __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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13, __v_14]; 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 __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_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 __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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13, __v_16]; 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 __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() {
@@ -33161,16 +32099,16 @@ fn aiur_fn_361(
                 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_361] = [__v_19, __v_23];
-                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_347] = [__v_19, __v_23];
+                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_19: 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 __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_20: G = __r_arr[0];
-                let __ret: [G; OUT_361] = [__v_19, __v_20];
-                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_347] = [__v_19, __v_20];
+                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -33181,8 +32119,8 @@ fn aiur_fn_361(
             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));
+            let __ret: [G; OUT_347] = [__v_13, __v_17];
+            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33194,15 +32132,15 @@ fn aiur_fn_361(
   })
 }
 
-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_348: usize = 2;
+const IN_348: usize = 2;
+const OUT_348: usize = 2;
+fn aiur_fn_348(
+  inp: [G; IN_348],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_362], 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];
@@ -33213,15 +32151,15 @@ fn aiur_fn_362(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_3]; 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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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 __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_6, __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 __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_308] = { let __args: [G; IN_308] = []; 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 __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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_6, __v_9]; 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 __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() {
@@ -33231,14 +32169,14 @@ fn aiur_fn_362(
             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_362] = [__v_12, __v_16];
-            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_348] = [__v_12, __v_16];
+            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(1);
-            let __ret: [G; OUT_362] = [__v_12, __v_0];
-            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_348] = [__v_12, __v_0];
+            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33249,23 +32187,23 @@ fn aiur_fn_362(
         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_362] = [__v_6, __v_10];
-        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_348] = [__v_6, __v_10];
+        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_363: usize = 1;
-const IN_363: usize = 1;
-const OUT_363: usize = 2;
-fn aiur_fn_363(
-  inp: [G; IN_363],
+const INPUT_SIZE_349: usize = 1;
+const IN_349: usize = 1;
+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_363], ExecError> {
+) -> Result<[G; OUT_349], 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 };
@@ -33278,8 +32216,8 @@ fn aiur_fn_363(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_363] = [__v_5, __v_0];
-            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_349] = [__v_5, __v_0];
+            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -33288,8 +32226,8 @@ fn aiur_fn_363(
             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_363] = [__v_5, __v_9];
-            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_349] = [__v_5, __v_9];
+            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33300,23 +32238,23 @@ fn aiur_fn_363(
         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_363] = [__v_5, __v_9];
-        record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_349] = [__v_5, __v_9];
+        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_364: usize = 7;
-const IN_364: usize = 7;
-const OUT_364: usize = 2;
-fn aiur_fn_364(
-  inp: [G; IN_364],
+const INPUT_SIZE_350: usize = 7;
+const IN_350: usize = 7;
+const OUT_350: usize = 2;
+fn aiur_fn_350(
+  inp: [G; IN_350],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_364], 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];
@@ -33325,39 +32263,39 @@ fn aiur_fn_364(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    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 __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_130] = { let __args: [G; IN_130] = [__v_0, __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 __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_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 __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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_9]; 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 __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_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 __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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_11]; 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 __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_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 __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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_13]; 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 __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_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 __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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_15]; 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 __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_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 __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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_17]; 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 __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() {
       1u64 => {
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
-        let __ret: [G; OUT_364] = [__v_21, __v_22];
-        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_350] = [__v_21, __v_22];
+        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33370,12 +32308,12 @@ fn aiur_fn_364(
             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_364] = [__v_23, __v_27];
-            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_350] = [__v_23, __v_27];
+            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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 };
@@ -33386,16 +32324,16 @@ fn aiur_fn_364(
                 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_364] = [__v_26, __v_30];
-                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_350] = [__v_26, __v_30];
+                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__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[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 __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__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[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_26: G = __r_arr[0];
                 let __v_27: G = __r_arr[1];
-                let __ret: [G; OUT_364] = [__v_26, __v_27];
-                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_350] = [__v_26, __v_27];
+                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33409,15 +32347,15 @@ fn aiur_fn_364(
   })
 }
 
-const INPUT_SIZE_365: usize = 2;
-const IN_365: usize = 2;
-const OUT_365: usize = 3;
-fn aiur_fn_365(
-  inp: [G; IN_365],
+const INPUT_SIZE_351: usize = 2;
+const IN_351: usize = 2;
+const OUT_351: usize = 3;
+fn aiur_fn_351(
+  inp: [G; IN_351],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_365], 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];
@@ -33435,15 +32373,15 @@ fn aiur_fn_365(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_7]; 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 __v_10: G = __r_arr[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 __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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10, __v_11]; 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 __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_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 __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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_10, __v_13]; 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 __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() {
@@ -33453,8 +32391,8 @@ fn aiur_fn_365(
                 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_365] = [__v_16, __v_17, __v_20];
-                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_351] = [__v_16, __v_17, __v_20];
+                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33468,8 +32406,8 @@ fn aiur_fn_365(
                     match __v_17.as_canonical_u64() {
                       0u64 => {
                         let __v_20: G = G::from_u64(1);
-                        let __ret: [G; OUT_365] = [__v_20, __v_14, __v_18];
-                        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_351] = [__v_20, __v_14, __v_18];
+                        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -33478,8 +32416,8 @@ fn aiur_fn_365(
                         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_365] = [__v_20, __v_21, __v_24];
-                        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_351] = [__v_20, __v_21, __v_24];
+                        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -33490,8 +32428,8 @@ fn aiur_fn_365(
                     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_365] = [__v_20, __v_21, __v_24];
-                    record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_351] = [__v_20, __v_21, __v_24];
+                    record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -33504,8 +32442,8 @@ fn aiur_fn_365(
             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_365] = [__v_10, __v_11, __v_14];
-            record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_351] = [__v_10, __v_11, __v_14];
+            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33516,35 +32454,35 @@ fn aiur_fn_365(
         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_365] = [__v_6, __v_7, __v_10];
-        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_351] = [__v_6, __v_7, __v_10];
+        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_366: usize = 3;
-const IN_366: usize = 3;
-const OUT_366: usize = 2;
-fn aiur_fn_366(
-  inp: [G; IN_366],
+const INPUT_SIZE_352: usize = 3;
+const IN_352: usize = 3;
+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_366], 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.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 __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_3: G = __r_arr[0];
     break '__mc_0 [__v_3];
   },
   _ => {
-    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 __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_3: G = __r_arr[0];
     break '__mc_0 [__v_3];
   },
@@ -33552,7 +32490,7 @@ fn aiur_fn_366(
  };
     let __v_3: G = __mc_out___mc_0[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_2, __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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_2, __v_4]; 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 __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
@@ -33565,12 +32503,12 @@ fn aiur_fn_366(
         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_344] = { let __args: [G; IN_344] = [__v_1]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1]; 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(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_366] = [__v_13, __v_17];
-        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_352] = [__v_13, __v_17];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -33579,8 +32517,8 @@ fn aiur_fn_366(
         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_366] = [__v_7, __v_11];
-        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_352] = [__v_7, __v_11];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33590,15 +32528,15 @@ fn aiur_fn_366(
   })
 }
 
-const INPUT_SIZE_367: usize = 6;
-const IN_367: usize = 6;
-const OUT_367: usize = 2;
-fn aiur_fn_367(
-  inp: [G; IN_367],
+const INPUT_SIZE_353: usize = 6;
+const IN_353: usize = 6;
+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_367], 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];
@@ -33606,7 +32544,7 @@ fn aiur_fn_367(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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 };
@@ -33617,24 +32555,24 @@ fn aiur_fn_367(
         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_367] = [__v_9, __v_13];
-        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_353] = [__v_9, __v_13];
+        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_9]; 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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_11]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_11]; 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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_10, __v_5]; 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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_10, __v_5]; 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_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_365] = { let __args: [G; IN_365] = [__v_12, __v_5]; 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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_12, __v_5]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             let __v_18: G = __r_arr[2];
@@ -33645,26 +32583,26 @@ fn aiur_fn_367(
                 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));
+                let __ret: [G; OUT_353] = [__v_19, __v_23];
+                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__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[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 __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__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[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_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
-                let __ret: [G; OUT_367] = [__v_19, __v_20];
-                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_353] = [__v_19, __v_20];
+                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__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[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 __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__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[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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __ret: [G; OUT_367] = [__v_16, __v_17];
-            record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_353] = [__v_16, __v_17];
+            record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33676,15 +32614,15 @@ fn aiur_fn_367(
   })
 }
 
-const INPUT_SIZE_368: usize = 8;
-const IN_368: usize = 8;
-const OUT_368: usize = 2;
-fn aiur_fn_368(
-  inp: [G; IN_368],
+const INPUT_SIZE_354: usize = 8;
+const IN_354: usize = 8;
+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_368], 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];
@@ -33694,28 +32632,28 @@ fn aiur_fn_368(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_3, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5, __v_6, __v_7]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5, __v_6, __v_7]; 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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_8, __v_7]; 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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_8, __v_7]; 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_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() {
       1u64 => {
-        let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_9, __v_7]; 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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_9, __v_7]; 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_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_11, __v_12, __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 __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_11, __v_12, __v_7]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             match __v_16.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_14, __v_15, __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 __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_14, __v_15, __v_7]; 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_18: G = __r_arr[0];
                 let __v_19: G = __r_arr[1];
                 match __v_18.as_canonical_u64() {
@@ -33730,13 +32668,13 @@ fn aiur_fn_368(
                     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_799] = { let __args: [G; IN_799] = [__v_2, __v_29]; 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_769] = { let __args: [G; IN_769] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_28, __v_30]; 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_400] = { let __args: [G; IN_400] = [__v_28, __v_30]; 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_32: G = __r_arr[0];
-                    let __ret: [G; OUT_368] = [__v_31, __v_32];
-                    record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_354] = [__v_31, __v_32];
+                    record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -33745,8 +32683,8 @@ fn aiur_fn_368(
                     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_368] = [__v_20, __v_24];
-                    record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_354] = [__v_20, __v_24];
+                    record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -33757,8 +32695,8 @@ fn aiur_fn_368(
                 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_368] = [__v_18, __v_22];
-                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_354] = [__v_18, __v_22];
+                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -33769,8 +32707,8 @@ fn aiur_fn_368(
             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_368] = [__v_16, __v_20];
-            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_354] = [__v_16, __v_20];
+            record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33781,23 +32719,23 @@ fn aiur_fn_368(
         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_368] = [__v_13, __v_17];
-        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_354] = [__v_13, __v_17];
+        record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_369: usize = 9;
-const IN_369: usize = 9;
-const OUT_369: usize = 2;
-fn aiur_fn_369(
-  inp: [G; IN_369],
+const INPUT_SIZE_355: usize = 9;
+const IN_355: usize = 9;
+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_369], 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];
@@ -33811,14 +32749,14 @@ fn aiur_fn_369(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_9]; 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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __v_11]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_11]; 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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_6, __v_7, __v_8]; 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_414] = { let __args: [G; IN_414] = [__v_10, __v_6, __v_7, __v_8]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_13, __v_8]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_13, __v_8]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
@@ -33828,14 +32766,14 @@ fn aiur_fn_369(
             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));
+            let __ret: [G; OUT_355] = [__v_16, __v_20];
+            record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_15]; 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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_16]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __v_18: G = G::from_u64(2);
             let __v_19: G = G::from_u64(0);
@@ -33844,10 +32782,10 @@ fn aiur_fn_369(
             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_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 __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_25: G = __r_arr[0];
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_25, __v_8, __v_26]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_25, __v_8, __v_26]; 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_27: G = __r_arr[0];
             let __v_28: G = __r_arr[1];
             match __v_27.as_canonical_u64() {
@@ -33857,8 +32795,8 @@ fn aiur_fn_369(
                 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_369] = [__v_29, __v_33];
-                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_355] = [__v_29, __v_33];
+                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -33875,13 +32813,13 @@ fn aiur_fn_369(
                 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_799] = { let __args: [G; IN_799] = [__v_5, __v_41]; 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_769] = { let __args: [G; IN_769] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
                 let __v_42: G = __r_arr[0];
-                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_40, __v_42]; 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_400] = { let __args: [G; IN_400] = [__v_40, __v_42]; 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_43: G = __r_arr[0];
                 let __v_44: G = G::from_u64(1);
-                let __ret: [G; OUT_369] = [__v_44, __v_43];
-                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_355] = [__v_44, __v_43];
+                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33895,11 +32833,11 @@ fn aiur_fn_369(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__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[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 __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__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[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];
-        let __ret: [G; OUT_369] = [__v_9, __v_10];
-        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_355] = [__v_9, __v_10];
+        record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33909,15 +32847,15 @@ fn aiur_fn_369(
   })
 }
 
-const INPUT_SIZE_370: usize = 8;
-const IN_370: usize = 8;
-const OUT_370: usize = 2;
-fn aiur_fn_370(
-  inp: [G; IN_370],
+const INPUT_SIZE_356: usize = 8;
+const IN_356: usize = 8;
+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_370], 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];
@@ -33928,19 +32866,19 @@ fn aiur_fn_370(
     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_781] = { let __args: [G; IN_781] = [__v_4, __v_8]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_8]; 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 __v_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(1);
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_10]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_10]; 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 __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5, __v_6, __v_7]; 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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_11, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_11, __v_5, __v_6, __v_7]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_12, __v_7]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_12, __v_7]; 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_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_13, __v_7]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_13, __v_7]; 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_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
     match __v_14.as_canonical_u64() {
@@ -33950,8 +32888,8 @@ fn aiur_fn_370(
         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_370] = [__v_18, __v_22];
-        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_356] = [__v_18, __v_22];
+        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -33962,19 +32900,19 @@ fn aiur_fn_370(
             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_370] = [__v_18, __v_22];
-            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_356] = [__v_18, __v_22];
+            record.function_queries[356].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_316] = { let __args: [G; IN_316] = [__v_15, __v_17]; 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 __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_15, __v_17]; 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_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
   0u64 => {
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_15, __v_17]; 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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_15, __v_17]; 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_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
@@ -33984,11 +32922,11 @@ fn aiur_fn_370(
 }
  };
             let __v_18: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__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[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 __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__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[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_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_370] = [__v_19, __v_20];
-            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_356] = [__v_19, __v_20];
+            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34003,15 +32941,15 @@ fn aiur_fn_370(
   })
 }
 
-const INPUT_SIZE_371: usize = 11;
-const IN_371: usize = 11;
-const OUT_371: usize = 2;
-fn aiur_fn_371(
-  inp: [G; IN_371],
+const INPUT_SIZE_357: usize = 11;
+const IN_357: usize = 11;
+const OUT_357: usize = 2;
+fn aiur_fn_357(
+  inp: [G; IN_357],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_371], 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];
@@ -34024,10 +32962,10 @@ fn aiur_fn_371(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    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 __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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_11, __v_10, __v_12]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_11, __v_10, __v_12]; 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     match __v_13.as_canonical_u64() {
@@ -34037,15 +32975,15 @@ fn aiur_fn_371(
         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_371] = [__v_15, __v_19];
-        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_357] = [__v_15, __v_19];
+        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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 __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_15: G = __r_arr[0];
         let __v_16: G = G::from_u64(0);
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_15, __v_10, __v_16]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_15, __v_10, __v_16]; 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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         match __v_17.as_canonical_u64() {
@@ -34055,26 +32993,26 @@ fn aiur_fn_371(
             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_371] = [__v_19, __v_23];
-            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_357] = [__v_19, __v_23];
+            record.function_queries[357].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() {
   1u64 => {
-    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = []; 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 __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_19: G = __r_arr[0];
     let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_19, __v_10, __v_20]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_19, __v_10, __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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
   },
   0u64 => {
-    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = []; 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 __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_19: G = __r_arr[0];
     let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_19, __v_10, __v_20]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_19, __v_10, __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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -34093,8 +33031,8 @@ fn aiur_fn_371(
                 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_371] = [__v_21, __v_25];
-                record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_357] = [__v_21, __v_25];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -34134,12 +33072,12 @@ fn aiur_fn_371(
   1u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        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 __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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
       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 __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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
@@ -34151,12 +33089,12 @@ fn aiur_fn_371(
   0u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        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 __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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
       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 __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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
@@ -34172,7 +33110,7 @@ fn aiur_fn_371(
  };
                 let __v_53: G = __mc_out___mc_1[0];
                 let __v_54: G = G::from_u64(0);
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_53, __v_10, __v_54]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_53, __v_10, __v_54]; 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_55: G = __r_arr[0];
                 let __v_56: G = __r_arr[1];
                 match __v_55.as_canonical_u64() {
@@ -34182,8 +33120,8 @@ fn aiur_fn_371(
                     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_371] = [__v_57, __v_61];
-                    record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_357] = [__v_57, __v_61];
+                    record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -34197,8 +33135,8 @@ fn aiur_fn_371(
                         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_371] = [__v_60, __v_64];
-                        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_357] = [__v_60, __v_64];
+                        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
@@ -34217,11 +33155,11 @@ fn aiur_fn_371(
                         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_372] = { let __args: [G; IN_372] = [__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[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 __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__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[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_75: G = __r_arr[0];
                         let __v_76: G = __r_arr[1];
-                        let __ret: [G; OUT_371] = [__v_75, __v_76];
-                        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_357] = [__v_75, __v_76];
+                        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -34251,15 +33189,15 @@ fn aiur_fn_371(
   })
 }
 
-const INPUT_SIZE_372: usize = 8;
-const IN_372: usize = 8;
-const OUT_372: usize = 2;
-fn aiur_fn_372(
-  inp: [G; IN_372],
+const INPUT_SIZE_358: usize = 8;
+const IN_358: usize = 8;
+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_372], ExecError> {
+) -> 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];
@@ -34271,12 +33209,12 @@ fn aiur_fn_372(
     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_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 __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_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
   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 __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_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -34287,7 +33225,7 @@ fn aiur_fn_372(
  };
     let __v_8: G = __mc_out___mc_0[0];
     let __v_9: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_8, __v_7, __v_9]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_8, __v_7, __v_9]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     match __v_10.as_canonical_u64() {
@@ -34297,8 +33235,8 @@ fn aiur_fn_372(
         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_372] = [__v_12, __v_16];
-        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_358] = [__v_12, __v_16];
+        record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -34306,18 +33244,18 @@ fn aiur_fn_372(
         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_795] = { let __args: [G; IN_795] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4, __v_15]; 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 __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_14, __v_16]; 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_400] = { let __args: [G; IN_400] = [__v_14, __v_16]; 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_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_17, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_17, __v_5, __v_6, __v_7]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_18, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_5, __v_6, __v_7]; 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_19]; 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 __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_200] = { let __args: [G; IN_200] = [__v_21]; 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 __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 };
@@ -34328,13 +33266,13 @@ fn aiur_fn_372(
             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_372] = [__v_25, __v_29];
-            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_358] = [__v_25, __v_29];
+            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_25: G = G::from_u64(0);
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_21, __v_25]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_21, __v_25]; 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 __v_26: G = __r_arr[0];
             let __v_27: G = G::from_u64(2);
             let __v_28: G = G::from_u64(1);
@@ -34349,13 +33287,13 @@ fn aiur_fn_372(
             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_799] = { let __args: [G; IN_799] = [__v_4, __v_39]; 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_769] = { let __args: [G; IN_769] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_38, __v_40]; 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_400] = { let __args: [G; IN_400] = [__v_38, __v_40]; 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_42: G = __r_arr[0];
-            let __ret: [G; OUT_372] = [__v_41, __v_42];
-            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_358] = [__v_41, __v_42];
+            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34370,20 +33308,20 @@ fn aiur_fn_372(
   })
 }
 
-const INPUT_SIZE_373: usize = 3;
-const IN_373: usize = 3;
-const OUT_373: usize = 2;
-fn aiur_fn_373(
-  inp: [G; IN_373],
+const INPUT_SIZE_359: usize = 3;
+const IN_359: usize = 3;
+const OUT_359: usize = 2;
+fn aiur_fn_359(
+  inp: [G; IN_359],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_373], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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 };
@@ -34394,13 +33332,13 @@ fn aiur_fn_373(
         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_373] = [__v_6, __v_10];
-        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_359] = [__v_6, __v_10];
+        record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_6]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_6]; 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 __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];
@@ -34411,13 +33349,13 @@ fn aiur_fn_373(
           7u64 => {
             match __v_9.as_canonical_u64() {
               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 __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_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_12]; 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 __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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10]; 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 __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_10]; 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 __v_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
                     let __v_16: G = __r_arr[2];
@@ -34436,32 +33374,32 @@ fn aiur_fn_373(
                     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_373] = [__v_27, __v_31];
-                    record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_359] = [__v_27, __v_31];
+                    record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    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 __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_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_14]; 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 __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_374] = { let __args: [G; IN_374] = [__v_10, __v_2]; 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 __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_10, __v_2]; 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_16: G = __r_arr[0];
                         let __v_17: G = __r_arr[1];
-                        let __ret: [G; OUT_373] = [__v_16, __v_17];
-                        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_359] = [__v_16, __v_17];
+                        record.function_queries[359].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 __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_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_16]; 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 __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_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 __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_18: G = __r_arr[0];
-                        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_18]; 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 __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() {
@@ -34471,16 +33409,16 @@ fn aiur_fn_373(
                             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_373] = [__v_21, __v_25];
-                            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_359] = [__v_21, __v_25];
+                            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_10, __v_2]; 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 __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_10, __v_2]; 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_21: G = __r_arr[0];
                             let __v_22: G = __r_arr[1];
-                            let __ret: [G; OUT_373] = [__v_21, __v_22];
-                            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_359] = [__v_21, __v_22];
+                            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -34501,8 +33439,8 @@ fn aiur_fn_373(
                 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));
+                let __ret: [G; OUT_359] = [__v_12, __v_16];
+                record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -34513,8 +33451,8 @@ fn aiur_fn_373(
             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));
+            let __ret: [G; OUT_359] = [__v_12, __v_16];
+            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -34526,15 +33464,15 @@ fn aiur_fn_373(
   })
 }
 
-const INPUT_SIZE_374: usize = 2;
-const IN_374: usize = 2;
-const OUT_374: usize = 2;
-fn aiur_fn_374(
-  inp: [G; IN_374],
+const INPUT_SIZE_360: usize = 2;
+const IN_360: usize = 2;
+const OUT_360: usize = 2;
+fn aiur_fn_360(
+  inp: [G; IN_360],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_374], 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];
@@ -34544,10 +33482,10 @@ fn aiur_fn_374(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       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 __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_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_6]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_5, __v_1, __v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         match __v_7.as_canonical_u64() {
@@ -34559,8 +33497,8 @@ fn aiur_fn_374(
             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_374] = [__v_9, __v_15];
-            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_360] = [__v_9, __v_15];
+            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -34569,8 +33507,8 @@ fn aiur_fn_374(
             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_374] = [__v_9, __v_13];
-            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_360] = [__v_9, __v_13];
+            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34584,30 +33522,30 @@ fn aiur_fn_374(
         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_374] = [__v_5, __v_9];
-        record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_360] = [__v_5, __v_9];
+        record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_375: usize = 2;
-const IN_375: usize = 2;
-const OUT_375: usize = 2;
-fn aiur_fn_375(
-  inp: [G; IN_375],
+const INPUT_SIZE_361: usize = 2;
+const IN_361: usize = 2;
+const OUT_361: usize = 2;
+fn aiur_fn_361(
+  inp: [G; IN_361],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_375], 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 __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_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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_1, __v_3]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -34617,14 +33555,14 @@ fn aiur_fn_375(
         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_361] = [__v_6, __v_10];
+        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0]; 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 __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6]; 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 __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(7);
         let __v_9: G = G::from_u64(0);
@@ -34640,8 +33578,8 @@ fn aiur_fn_375(
         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_375] = [__v_18, __v_21];
-        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_361] = [__v_18, __v_21];
+        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -34651,51 +33589,51 @@ fn aiur_fn_375(
   })
 }
 
-const INPUT_SIZE_376: usize = 1;
-const IN_376: usize = 1;
-const OUT_376: usize = 4;
-fn aiur_fn_376(
-  inp: [G; IN_376],
+const INPUT_SIZE_362: usize = 1;
+const IN_362: usize = 1;
+const OUT_362: usize = 4;
+fn aiur_fn_362(
+  inp: [G; IN_362],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_376], ExecError> {
+) -> Result<[G; OUT_362], 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_318] = { let __args: [G; IN_318] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __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_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_318] = { let __args: [G; IN_318] = [__v_3, __v_4]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_4]; 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 __v_6: G = __r_arr[1];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_7]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_7]; 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_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_318] = { let __args: [G; IN_318] = [__v_9, __v_10]; 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_10]; 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __ret: [G; OUT_376] = [__v_2, __v_5, __v_8, __v_11];
-    record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_362] = [__v_2, __v_5, __v_8, __v_11];
+    record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_377: usize = 1;
-const IN_377: usize = 1;
-const OUT_377: usize = 1;
-fn aiur_fn_377(
-  inp: [G; IN_377],
+const INPUT_SIZE_363: usize = 1;
+const IN_363: usize = 1;
+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_377], ExecError> {
+) -> Result<[G; OUT_363], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -34729,41 +33667,41 @@ fn aiur_fn_377(
     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_377] = [__v_30];
-    record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_363] = [__v_30];
+    record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_378: usize = 1;
-const IN_378: usize = 1;
-const OUT_378: usize = 1;
-fn aiur_fn_378(
-  inp: [G; IN_378],
+const INPUT_SIZE_364: usize = 1;
+const IN_364: usize = 1;
+const OUT_364: usize = 1;
+fn aiur_fn_364(
+  inp: [G; IN_364],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_378], ExecError> {
+) -> Result<[G; OUT_364], 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_379] = { let __args: [G; IN_379] = [__v_0, __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 __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __ret: [G; OUT_378] = [__v_2];
-    record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_364] = [__v_2];
+    record.function_queries[364].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],
+const INPUT_SIZE_365: usize = 2;
+const IN_365: usize = 2;
+const OUT_365: usize = 1;
+fn aiur_fn_365(
+  inp: [G; IN_365],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_379], ExecError> {
+) -> Result<[G; OUT_365], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34773,18 +33711,18 @@ fn aiur_fn_379(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_379] = [__v_1];
-        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_365] = [__v_1];
+        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_3, __v_4]; 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 __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4]; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_6, __v_5]; 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 __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_6, __v_5]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_379] = [__v_7];
-        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_365] = [__v_7];
+        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -34794,15 +33732,15 @@ fn aiur_fn_379(
   })
 }
 
-const INPUT_SIZE_380: usize = 2;
-const IN_380: usize = 2;
-const OUT_380: usize = 2;
-fn aiur_fn_380(
-  inp: [G; IN_380],
+const INPUT_SIZE_366: usize = 2;
+const IN_366: usize = 2;
+const OUT_366: usize = 2;
+fn aiur_fn_366(
+  inp: [G; IN_366],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_380], 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];
@@ -34810,8 +33748,8 @@ fn aiur_fn_380(
     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 => {
-        let __ret: [G; OUT_380] = [__v_0, __v_1];
-        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_366] = [__v_0, __v_1];
+        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -34832,8 +33770,8 @@ fn aiur_fn_380(
                 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_380] = [__v_15, __v_8];
-                record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_366] = [__v_15, __v_8];
+                record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -34870,8 +33808,8 @@ fn aiur_fn_380(
                         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_380] = [__v_25, __v_13];
-                        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_366] = [__v_25, __v_13];
+                        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -34920,8 +33858,8 @@ fn aiur_fn_380(
                             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_380] = [__v_33, __v_16];
-                            record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_366] = [__v_33, __v_16];
+                            record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -34956,22 +33894,22 @@ fn aiur_fn_380(
   })
 }
 
-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_367: usize = 2;
+const IN_367: usize = 2;
+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_381], 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];
-    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; 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 __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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_1, __v_3]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -34981,15 +33919,15 @@ fn aiur_fn_381(
         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_381] = [__v_6, __v_10];
-        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_367] = [__v_6, __v_10];
+        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; 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 __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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_1, __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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_6, __v_1, __v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -34999,15 +33937,15 @@ fn aiur_fn_381(
             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_381] = [__v_10, __v_14];
-            record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_367] = [__v_10, __v_14];
+            record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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 __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_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_10, __v_1, __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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_10, __v_1, __v_11]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
@@ -35017,15 +33955,15 @@ fn aiur_fn_381(
                 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_381] = [__v_14, __v_18];
-                record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_367] = [__v_14, __v_18];
+                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               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 __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_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_14, __v_1, __v_15]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_14, __v_1, __v_15]; 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_16: G = __r_arr[0];
                 let __v_17: G = __r_arr[1];
                 match __v_16.as_canonical_u64() {
@@ -35035,15 +33973,15 @@ fn aiur_fn_381(
                     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_381] = [__v_18, __v_22];
-                    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_367] = [__v_18, __v_22];
+                    record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; 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 __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_18: G = __r_arr[0];
                     let __v_19: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_18, __v_1, __v_19]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_18, __v_1, __v_19]; 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_20: G = __r_arr[0];
                     let __v_21: G = __r_arr[1];
                     match __v_20.as_canonical_u64() {
@@ -35053,8 +33991,8 @@ fn aiur_fn_381(
                         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_381] = [__v_22, __v_26];
-                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_367] = [__v_22, __v_26];
+                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
@@ -35096,14 +34034,14 @@ fn aiur_fn_381(
                         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_382] = { let __args: [G; IN_382] = [__v_0, __v_56, __v_59, __v_47]; 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 __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_56, __v_59, __v_47]; 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_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_381] = [__v_61, __v_64];
-                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_367] = [__v_61, __v_64];
+                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -35133,15 +34071,15 @@ fn aiur_fn_381(
   })
 }
 
-const INPUT_SIZE_382: usize = 4;
-const IN_382: usize = 4;
-const OUT_382: usize = 1;
-fn aiur_fn_382(
-  inp: [G; IN_382],
+const INPUT_SIZE_368: usize = 4;
+const IN_368: usize = 4;
+const OUT_368: usize = 1;
+fn aiur_fn_368(
+  inp: [G; IN_368],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_382], 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];
@@ -35153,15 +34091,15 @@ fn aiur_fn_382(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_382] = [__v_1];
-        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_368] = [__v_1];
+        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_5, __v_6]; 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 __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__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 __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_7]; 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(7);
         let __v_11: G = G::from_u64(0);
@@ -35173,13 +34111,13 @@ fn aiur_fn_382(
         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_382] = { let __args: [G; IN_382] = [__v_8, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_1, __v_2, __v_3]; 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_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_382] = [__v_23];
-        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_368] = [__v_23];
+        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35189,15 +34127,15 @@ fn aiur_fn_382(
   })
 }
 
-const INPUT_SIZE_383: usize = 2;
-const IN_383: usize = 2;
-const OUT_383: usize = 1;
-fn aiur_fn_383(
-  inp: [G; IN_383],
+const INPUT_SIZE_369: usize = 2;
+const IN_369: usize = 2;
+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_383], 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];
@@ -35210,18 +34148,18 @@ fn aiur_fn_383(
       7u64 => {
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__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 __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1]; 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_383] = [__v_7];
-                record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_369] = [__v_7];
+                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_383] = [__v_0];
-                record.function_queries[383].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);
               },
               _ => {
@@ -35230,35 +34168,35 @@ fn aiur_fn_383(
             }
           },
           _ => {
-            let __ret: [G; OUT_383] = [__v_0];
-            record.function_queries[383].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);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_383] = [__v_0];
-        record.function_queries[383].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);
       },
     }
   })
 }
 
-const INPUT_SIZE_384: usize = 3;
-const IN_384: usize = 3;
-const OUT_384: usize = 2;
-fn aiur_fn_384(
-  inp: [G; IN_384],
+const INPUT_SIZE_370: usize = 3;
+const IN_370: usize = 3;
+const OUT_370: usize = 2;
+fn aiur_fn_370(
+  inp: [G; IN_370],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_384], 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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_0]; 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 __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];
@@ -35275,7 +34213,7 @@ fn aiur_fn_384(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7, __v_15]; 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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_7, __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 __v_17: G = __r_arr[1];
         let __v_18: G = __r_arr[2];
@@ -35283,7 +34221,7 @@ fn aiur_fn_384(
         let __v_20: G = __r_arr[4];
         match __v_16.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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 };
             match __v_22.as_canonical_u64() {
@@ -35293,22 +34231,22 @@ fn aiur_fn_384(
                 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_384] = [__v_23, __v_27];
-                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_370] = [__v_23, __v_27];
+                record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_20]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_20]; 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 __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_799] = { let __args: [G; IN_799] = [__v_1, __v_17]; 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_769] = { let __args: [G; IN_769] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_25, __v_26]; 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_400] = { let __args: [G; IN_400] = [__v_25, __v_26]; 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_28: G = __r_arr[0];
-                let __ret: [G; OUT_384] = [__v_27, __v_28];
-                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_370] = [__v_27, __v_28];
+                record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -35322,8 +34260,8 @@ fn aiur_fn_384(
             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_384] = [__v_21, __v_25];
-            record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_370] = [__v_21, __v_25];
+            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35334,34 +34272,34 @@ fn aiur_fn_384(
         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_384] = [__v_15, __v_19];
-        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_370] = [__v_15, __v_19];
+        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_385: usize = 5;
-const IN_385: usize = 5;
-const OUT_385: usize = 2;
-fn aiur_fn_385(
-  inp: [G; IN_385],
+const INPUT_SIZE_371: usize = 5;
+const IN_371: usize = 5;
+const OUT_371: usize = 2;
+fn aiur_fn_371(
+  inp: [G; IN_371],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_385], 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];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_0]; 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 __v_5: G = __r_arr[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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_6]; 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 __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 => {
@@ -35370,8 +34308,8 @@ fn aiur_fn_385(
         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_385] = [__v_8, __v_12];
-        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_371] = [__v_8, __v_12];
+        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -35384,11 +34322,11 @@ fn aiur_fn_385(
             let __v_11: G = __loaded[3];
             match __v_8.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_9]; 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 __v_12: G = __r_arr[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 __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_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_12, __v_13]; 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 __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 => {
@@ -35397,12 +34335,12 @@ fn aiur_fn_385(
                     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_385] = [__v_15, __v_19];
-                    record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_371] = [__v_15, __v_19];
+                    record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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 };
@@ -35413,25 +34351,25 @@ fn aiur_fn_385(
                         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_385] = [__v_18, __v_22];
-                        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_371] = [__v_18, __v_22];
+                        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
                         let __v_18: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_18]; 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 __v_19: G = __r_arr[0];
                         let __v_20: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_20]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_20]; 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 __v_21: G = __r_arr[0];
                         let __v_22: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_22]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_22]; 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 __v_23: G = __r_arr[0];
                         let __v_24: G = G::from_u64(3);
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_24]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_24]; 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 __v_25: G = __r_arr[0];
                         let __v_26: G = G::from_u64(4);
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_26]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_26]; 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 __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];
@@ -35464,10 +34402,10 @@ fn aiur_fn_385(
                                     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_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 __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_50: G = __r_arr[0];
                                     let __v_51: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_50, __v_4, __v_51]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_50, __v_4, __v_51]; 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_52: G = __r_arr[0];
                                     let __v_53: G = __r_arr[1];
                                     match __v_52.as_canonical_u64() {
@@ -35500,13 +34438,13 @@ fn aiur_fn_385(
                                         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_799] = { let __args: [G; IN_799] = [__v_3, __v_81]; 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_769] = { let __args: [G; IN_769] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_80, __v_82]; 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_400] = { let __args: [G; IN_400] = [__v_80, __v_82]; 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_84: G = __r_arr[0];
-                                        let __ret: [G; OUT_385] = [__v_83, __v_84];
-                                        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_371] = [__v_83, __v_84];
+                                        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       0u64 => {
@@ -35515,8 +34453,8 @@ fn aiur_fn_385(
                                         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_385] = [__v_54, __v_58];
-                                        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_371] = [__v_54, __v_58];
+                                        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -35530,8 +34468,8 @@ fn aiur_fn_385(
                                     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_385] = [__v_45, __v_49];
-                                    record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_371] = [__v_45, __v_49];
+                                    record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -35542,8 +34480,8 @@ fn aiur_fn_385(
                                 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_385] = [__v_36, __v_40];
-                                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_371] = [__v_36, __v_40];
+                                record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -35554,8 +34492,8 @@ fn aiur_fn_385(
                             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_385] = [__v_32, __v_36];
-                            record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_371] = [__v_32, __v_36];
+                            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -35576,8 +34514,8 @@ fn aiur_fn_385(
                 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_385] = [__v_12, __v_16];
-                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_371] = [__v_12, __v_16];
+                record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -35588,8 +34526,8 @@ fn aiur_fn_385(
             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_385] = [__v_8, __v_12];
-            record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_371] = [__v_8, __v_12];
+            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35601,15 +34539,15 @@ fn aiur_fn_385(
   })
 }
 
-const INPUT_SIZE_386: usize = 2;
-const IN_386: usize = 2;
-const OUT_386: usize = 5;
-fn aiur_fn_386(
-  inp: [G; IN_386],
+const INPUT_SIZE_372: usize = 2;
+const IN_372: usize = 2;
+const OUT_372: usize = 5;
+fn aiur_fn_372(
+  inp: [G; IN_372],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_386], 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];
@@ -35622,14 +34560,14 @@ fn aiur_fn_386(
       4u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __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_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_386] = [__v_8, __v_9, __v_10, __v_11, __v_12];
-        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_372] = [__v_8, __v_9, __v_10, __v_11, __v_12];
+        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
@@ -35647,8 +34585,8 @@ fn aiur_fn_386(
                 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_386] = [__v_11, __v_1, __v_3, __v_4, __v_14];
-                record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_372] = [__v_11, __v_1, __v_3, __v_4, __v_14];
+                record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -35657,8 +34595,8 @@ fn aiur_fn_386(
                 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_386] = [__v_11, __v_12, __v_13, __v_14, __v_15];
-                record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_372] = [__v_11, __v_12, __v_13, __v_14, __v_15];
+                record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -35669,8 +34607,8 @@ fn aiur_fn_386(
             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_386] = [__v_10, __v_11, __v_12, __v_13, __v_14];
-            record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_372] = [__v_10, __v_11, __v_12, __v_13, __v_14];
+            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35681,23 +34619,23 @@ fn aiur_fn_386(
         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_386] = [__v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_372] = [__v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_387: usize = 1;
-const IN_387: usize = 1;
-const OUT_387: usize = 1;
-fn aiur_fn_387(
-  inp: [G; IN_387],
+const INPUT_SIZE_373: usize = 1;
+const IN_373: usize = 1;
+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_387], ExecError> {
+) -> Result<[G; OUT_373], 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 };
@@ -35709,77 +34647,77 @@ fn aiur_fn_387(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 + __v_5);
-        let __ret: [G; OUT_387] = [__v_6];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_6];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_387] = [__v_5];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_5];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_387] = [__v_5];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_5];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_387] = [__v_5];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_5];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_5, __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 __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_6]; 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_387] = [__v_7];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_7];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_6]; 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 __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_6]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_5, __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 __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_7]; 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_387] = [__v_8];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_8];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_6]; 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 __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_6]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_5, __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 __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_7]; 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_387] = [__v_8];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_8];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_2, __v_3, __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_5: G = __r_arr[0];
-        let __ret: [G; OUT_387] = [__v_5];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_5];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_4]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_387] = [__v_5];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_5];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35789,59 +34727,59 @@ fn aiur_fn_387(
   })
 }
 
-const INPUT_SIZE_388: usize = 3;
-const IN_388: usize = 3;
-const OUT_388: usize = 1;
-fn aiur_fn_388(
-  inp: [G; IN_388],
+const INPUT_SIZE_374: usize = 3;
+const IN_374: usize = 3;
+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_388], 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 __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_3, __v_4]; 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 __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_3, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_2]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_6]; 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 __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_6]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_5, __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 __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_7]; 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_388] = [__v_8];
-    record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_374] = [__v_8];
+    record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_389: usize = 2;
-const IN_389: usize = 2;
-const OUT_389: usize = 1;
-fn aiur_fn_389(
-  inp: [G; IN_389],
+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_389], 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 = { 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_389] = [__v_1];
-        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_375] = [__v_1];
+        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_389] = [__v_0];
-        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_375] = [__v_0];
+        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35851,57 +34789,57 @@ fn aiur_fn_389(
   })
 }
 
-const INPUT_SIZE_390: usize = 1;
-const IN_390: usize = 1;
-const OUT_390: usize = 1;
-fn aiur_fn_390(
-  inp: [G; IN_390],
+const INPUT_SIZE_376: usize = 1;
+const IN_376: usize = 1;
+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_390], ExecError> {
+) -> Result<[G; OUT_376], 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_390] = [__v_1];
-        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_376] = [__v_1];
+        record.function_queries[376].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_390] = [__v_2];
-        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_376] = [__v_2];
+        record.function_queries[376].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_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_391], 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 = { 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_391] = [__v_0];
-        record.function_queries[391].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);
       },
       0u64 => {
-        let __ret: [G; OUT_391] = [__v_1];
-        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_377] = [__v_1];
+        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35911,15 +34849,15 @@ fn aiur_fn_391(
   })
 }
 
-const INPUT_SIZE_392: usize = 3;
-const IN_392: usize = 3;
-const OUT_392: usize = 1;
-fn aiur_fn_392(
-  inp: [G; IN_392],
+const INPUT_SIZE_378: usize = 3;
+const IN_378: usize = 3;
+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_392], 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];
@@ -35935,14 +34873,14 @@ fn aiur_fn_392(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_392] = [__v_8];
-            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_378] = [__v_8];
+            record.function_queries[378].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_392] = [__v_8];
-            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_378] = [__v_8];
+            record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -35952,37 +34890,37 @@ fn aiur_fn_392(
       },
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_392] = [__v_8];
-            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_378] = [__v_8];
+            record.function_queries[378].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_1, __v_2]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_1, __v_2]; 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_392] = [__v_8];
-            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_378] = [__v_8];
+            record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -35991,31 +34929,31 @@ fn aiur_fn_392(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_5, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_5, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_5, __v_6, __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 __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_6, __v_1, __v_2]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_6, __v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36025,27 +34963,27 @@ fn aiur_fn_392(
   })
 }
 
-const INPUT_SIZE_393: usize = 4;
-const IN_393: usize = 4;
-const OUT_393: usize = 1;
-fn aiur_fn_393(
-  inp: [G; IN_393],
+const INPUT_SIZE_379: usize = 4;
+const IN_379: usize = 4;
+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_393], ExecError> {
+) -> 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 __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_2, __v_3]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_2, __v_3]; 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_393] = [__v_5];
-        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_5];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -36053,10 +34991,10 @@ fn aiur_fn_393(
         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_392] = { let __args: [G; IN_392] = [__v_1, __v_6, __v_8]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_1, __v_6, __v_8]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_393] = [__v_9];
-        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_9];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36066,38 +35004,38 @@ fn aiur_fn_393(
   })
 }
 
-const INPUT_SIZE_394: usize = 5;
-const IN_394: usize = 5;
-const OUT_394: usize = 1;
-fn aiur_fn_394(
-  inp: [G; IN_394],
+const INPUT_SIZE_380: usize = 5;
+const IN_380: usize = 5;
+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_394], 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 = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_3, __v_4]; 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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_394] = [__v_6];
-        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_380] = [__v_6];
+        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_1, __v_3, __v_4]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_394] = [__v_7];
-            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_380] = [__v_7];
+            record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36105,10 +35043,10 @@ fn aiur_fn_394(
             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_392] = { let __args: [G; IN_392] = [__v_2, __v_8, __v_10]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_2, __v_8, __v_10]; 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_394] = [__v_11];
-            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_380] = [__v_11];
+            record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36123,60 +35061,60 @@ fn aiur_fn_394(
   })
 }
 
-const INPUT_SIZE_395: usize = 2;
-const IN_395: usize = 2;
-const OUT_395: usize = 1;
-fn aiur_fn_395(
-  inp: [G; IN_395],
+const INPUT_SIZE_381: usize = 2;
+const IN_381: usize = 2;
+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_395], ExecError> {
+) -> 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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; 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 __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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3]; 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_4: G = __r_arr[0];
-    let __ret: [G; OUT_395] = [__v_4];
-    record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_381] = [__v_4];
+    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_396: usize = 2;
-const IN_396: usize = 2;
-const OUT_396: usize = 1;
-fn aiur_fn_396(
-  inp: [G; IN_396],
+const INPUT_SIZE_382: usize = 2;
+const IN_382: usize = 2;
+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_396], 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 __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0]; 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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 = { 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_396] = [__v_2];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_382] = [__v_2];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_0, __v_2]; 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_769] = { let __args: [G; IN_769] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_396] = { let __args: [G; IN_396] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_396] = [__v_7];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_382] = [__v_7];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36186,15 +35124,15 @@ fn aiur_fn_396(
   })
 }
 
-const INPUT_SIZE_397: usize = 1;
-const IN_397: usize = 1;
-const OUT_397: usize = 1;
-fn aiur_fn_397(
-  inp: [G; IN_397],
+const INPUT_SIZE_383: usize = 1;
+const IN_383: usize = 1;
+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_397], ExecError> {
+) -> Result<[G; OUT_383], 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 };
@@ -36204,13 +35142,13 @@ fn aiur_fn_397(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_3, __v_5]; 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = (__v_4 + __v_6);
-        let __ret: [G; OUT_397] = [__v_7];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_383] = [__v_7];
+        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36220,44 +35158,44 @@ fn aiur_fn_397(
   })
 }
 
-const INPUT_SIZE_398: usize = 2;
-const IN_398: usize = 2;
-const OUT_398: usize = 1;
-fn aiur_fn_398(
-  inp: [G; IN_398],
+const INPUT_SIZE_384: usize = 2;
+const IN_384: usize = 2;
+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_398], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_398] = [__v_2];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_384] = [__v_2];
+        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0]; 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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0]; 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 = { 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_398] = [__v_2];
-            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_384] = [__v_2];
+            record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_0, __v_2]; 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_769] = { let __args: [G; IN_769] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_398] = { let __args: [G; IN_398] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_5]; 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_6: G = __r_arr[0];
             let __v_7: G = (__v_2 + __v_6);
-            let __ret: [G; OUT_398] = [__v_7];
-            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_384] = [__v_7];
+            record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36269,15 +35207,15 @@ fn aiur_fn_398(
   })
 }
 
-const INPUT_SIZE_399: usize = 2;
-const IN_399: usize = 2;
-const OUT_399: usize = 1;
-fn aiur_fn_399(
-  inp: [G; IN_399],
+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_399], 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];
@@ -36286,27 +35224,27 @@ fn aiur_fn_399(
         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_399] = [__v_4];
-        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_385] = [__v_4];
+        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 = { 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_399] = [__v_0];
-            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_385] = [__v_0];
+            record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __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_4: G = __r_arr[0];
-            let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_0, __v_4]; 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 __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_399] = [__v_5];
-            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_385] = [__v_5];
+            record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36318,40 +35256,40 @@ fn aiur_fn_399(
   })
 }
 
-const INPUT_SIZE_400: usize = 3;
-const IN_400: usize = 3;
-const OUT_400: usize = 1;
-fn aiur_fn_400(
-  inp: [G; IN_400],
+const INPUT_SIZE_386: usize = 3;
+const IN_386: usize = 3;
+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_400], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_400] = [__v_0];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_0];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_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_400] = [__v_0];
-            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_386] = [__v_0];
+            record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1, __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 __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1, __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_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_386] = [__v_5];
+            record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36363,15 +35301,15 @@ 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_387: usize = 3;
+const IN_387: usize = 3;
+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_401], 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];
@@ -36383,90 +35321,90 @@ fn aiur_fn_401(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __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 __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_4, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_401] = [__v_7];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_7];
+        record.function_queries[387].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_401] = [__v_9];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_9];
+        record.function_queries[387].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_401] = [__v_9];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_9];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_1, __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_386] = { let __args: [G; IN_386] = [__v_4, __v_1, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_1, __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_386] = { let __args: [G; IN_386] = [__v_5, __v_1, __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_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_401] = [__v_11];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_11];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_1, __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_386] = { let __args: [G; IN_386] = [__v_4, __v_1, __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_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_400] = { let __args: [G; IN_400] = [__v_5, __v_1, __v_10]; 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_386] = { let __args: [G; IN_386] = [__v_5, __v_1, __v_10]; 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_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_401] = [__v_13];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_13];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_1, __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_386] = { let __args: [G; IN_386] = [__v_4, __v_1, __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_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_400] = { let __args: [G; IN_400] = [__v_5, __v_1, __v_10]; 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_386] = { let __args: [G; IN_386] = [__v_5, __v_1, __v_10]; 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_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_401] = [__v_13];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_13];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_4, __v_5, __v_6, __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 __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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 __ret: [G; OUT_401] = [__v_7];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_7];
+        record.function_queries[387].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_401] = [__v_9];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_9];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __v_1, __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_386] = { let __args: [G; IN_386] = [__v_6, __v_1, __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_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_401] = [__v_9];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_9];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36476,15 +35414,15 @@ fn aiur_fn_401(
   })
 }
 
-const INPUT_SIZE_402: usize = 3;
-const IN_402: usize = 3;
-const OUT_402: usize = 1;
-fn aiur_fn_402(
-  inp: [G; IN_402],
+const INPUT_SIZE_388: usize = 3;
+const IN_388: usize = 3;
+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_402], ExecError> {
+) -> Result<[G; OUT_388], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36495,8 +35433,8 @@ fn aiur_fn_402(
         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_402] = [__v_6];
-        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_388] = [__v_6];
+        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -36504,8 +35442,8 @@ fn aiur_fn_402(
         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_402] = [__v_7];
-        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_388] = [__v_7];
+        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36515,15 +35453,15 @@ fn aiur_fn_402(
   })
 }
 
-const INPUT_SIZE_403: usize = 5;
-const IN_403: usize = 5;
-const OUT_403: usize = 1;
-fn aiur_fn_403(
-  inp: [G; IN_403],
+const INPUT_SIZE_389: usize = 5;
+const IN_389: usize = 5;
+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_403], 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];
@@ -36531,55 +35469,55 @@ fn aiur_fn_403(
     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_400] = { let __args: [G; IN_400] = [__v_0, __v_3, __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_386] = { let __args: [G; IN_386] = [__v_0, __v_3, __v_4]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __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_386] = { let __args: [G; IN_386] = [__v_1, __v_3, __v_4]; 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_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_400] = { let __args: [G; IN_400] = [__v_2, __v_3, __v_9]; 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_386] = { let __args: [G; IN_386] = [__v_2, __v_3, __v_9]; 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_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_403] = [__v_11];
-    record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_389] = [__v_11];
+    record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_404: usize = 3;
-const IN_404: usize = 3;
-const OUT_404: usize = 1;
-fn aiur_fn_404(
-  inp: [G; IN_404],
+const INPUT_SIZE_390: usize = 3;
+const IN_390: usize = 3;
+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_404], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_404] = [__v_0];
-        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_390] = [__v_0];
+        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_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_404] = [__v_0];
-            record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_390] = [__v_0];
+            record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_2]; 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 = __r_arr[0];
-            let __ret: [G; OUT_404] = [__v_5];
-            record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_390] = [__v_5];
+            record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36591,15 +35529,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_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_405], 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];
@@ -36614,8 +35552,8 @@ fn aiur_fn_405(
         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_405] = [__v_0];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_391] = [__v_0];
+            record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36623,8 +35561,8 @@ fn aiur_fn_405(
             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_405] = [__v_11];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_391] = [__v_11];
+            record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36636,88 +35574,88 @@ fn aiur_fn_405(
         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_405] = [__v_9];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_9];
+        record.function_queries[391].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_405] = [__v_9];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_9];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __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_390] = { let __args: [G; IN_390] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __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_390] = { let __args: [G; IN_390] = [__v_5, __v_1, __v_2]; 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(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_405] = [__v_11];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_11];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __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_390] = { let __args: [G; IN_390] = [__v_4, __v_1, __v_2]; 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_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_404] = { let __args: [G; IN_404] = [__v_5, __v_1, __v_10]; 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_390] = { let __args: [G; IN_390] = [__v_5, __v_1, __v_10]; 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_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_405] = [__v_13];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_13];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __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_390] = { let __args: [G; IN_390] = [__v_4, __v_1, __v_2]; 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_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_404] = { let __args: [G; IN_404] = [__v_5, __v_1, __v_10]; 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_390] = { let __args: [G; IN_390] = [__v_5, __v_1, __v_10]; 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_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_405] = [__v_13];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_13];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __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_390] = { let __args: [G; IN_390] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_5, __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_390] = { let __args: [G; IN_390] = [__v_5, __v_1, __v_2]; 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 __v_11: G = (__v_2 + __v_10);
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_6, __v_1, __v_11]; 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_390] = { let __args: [G; IN_390] = [__v_6, __v_1, __v_11]; 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_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_405] = [__v_13];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_13];
+        record.function_queries[391].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_405] = [__v_9];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_9];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_6, __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_390] = { let __args: [G; IN_390] = [__v_6, __v_1, __v_2]; 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_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_405] = [__v_9];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_9];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36727,33 +35665,33 @@ fn aiur_fn_405(
   })
 }
 
-const INPUT_SIZE_406: usize = 3;
-const IN_406: usize = 3;
-const OUT_406: usize = 1;
-fn aiur_fn_406(
-  inp: [G; IN_406],
+const INPUT_SIZE_392: usize = 3;
+const IN_392: usize = 3;
+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_406], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_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_406] = [__v_0];
-        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_0];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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 __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_406] = [__v_5];
-        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_5];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36763,15 +35701,15 @@ fn aiur_fn_406(
   })
 }
 
-const INPUT_SIZE_407: usize = 3;
-const IN_407: usize = 3;
-const OUT_407: usize = 1;
-fn aiur_fn_407(
-  inp: [G; IN_407],
+const INPUT_SIZE_393: usize = 3;
+const IN_393: usize = 3;
+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_407], ExecError> {
+) -> 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];
@@ -36783,90 +35721,90 @@ fn aiur_fn_407(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_4, __v_1, __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 __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_7];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_7];
+        record.function_queries[393].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_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_9];
+        record.function_queries[393].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_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_9];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_4, __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_392] = { let __args: [G; IN_392] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__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_392] = { let __args: [G; IN_392] = [__v_5, __v_1, __v_2]; 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_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_407] = [__v_11];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_11];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_4, __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_392] = { let __args: [G; IN_392] = [__v_4, __v_1, __v_2]; 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_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_406] = { let __args: [G; IN_406] = [__v_5, __v_1, __v_10]; 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_392] = { let __args: [G; IN_392] = [__v_5, __v_1, __v_10]; 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_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_407] = [__v_13];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_13];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_4, __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_392] = { let __args: [G; IN_392] = [__v_4, __v_1, __v_2]; 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_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_406] = { let __args: [G; IN_406] = [__v_5, __v_1, __v_10]; 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_392] = { let __args: [G; IN_392] = [__v_5, __v_1, __v_10]; 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_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_407] = [__v_13];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_13];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_4, __v_5, __v_6, __v_1, __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 __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_7];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_7];
+        record.function_queries[393].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_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_9];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __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_392] = { let __args: [G; IN_392] = [__v_6, __v_1, __v_2]; 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_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_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_9];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36876,15 +35814,15 @@ fn aiur_fn_407(
   })
 }
 
-const INPUT_SIZE_408: usize = 3;
-const IN_408: usize = 3;
-const OUT_408: usize = 1;
-fn aiur_fn_408(
-  inp: [G; IN_408],
+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_408], 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];
@@ -36895,8 +35833,8 @@ fn aiur_fn_408(
         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_408] = [__v_6];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_394] = [__v_6];
+        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -36904,10 +35842,10 @@ fn aiur_fn_408(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_2, __v_5]; 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_386] = { let __args: [G; IN_386] = [__v_1, __v_2, __v_5]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_408] = [__v_6];
-            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_394] = [__v_6];
+            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36916,8 +35854,8 @@ fn aiur_fn_408(
             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_408] = [__v_9];
-            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_394] = [__v_9];
+            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -36929,15 +35867,15 @@ fn aiur_fn_408(
   })
 }
 
-const INPUT_SIZE_409: usize = 5;
-const IN_409: usize = 5;
-const OUT_409: usize = 1;
-fn aiur_fn_409(
-  inp: [G; IN_409],
+const INPUT_SIZE_395: usize = 5;
+const IN_395: usize = 5;
+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_409], 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];
@@ -36945,48 +35883,48 @@ fn aiur_fn_409(
     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_406] = { let __args: [G; IN_406] = [__v_0, __v_3, __v_4]; 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_392] = { let __args: [G; IN_392] = [__v_0, __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1, __v_3, __v_4]; 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_392] = { let __args: [G; IN_392] = [__v_1, __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_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_406] = { let __args: [G; IN_406] = [__v_2, __v_3, __v_9]; 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_392] = { let __args: [G; IN_392] = [__v_2, __v_3, __v_9]; 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_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_409] = [__v_11];
-    record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_395] = [__v_11];
+    record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_410: usize = 3;
-const IN_410: usize = 3;
-const OUT_410: usize = 1;
-fn aiur_fn_410(
-  inp: [G; IN_410],
+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_410], 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 __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_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_410] = [__v_0];
-        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_396] = [__v_0];
+        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_1, __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 __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_1, __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_5: G = __r_arr[0];
-        let __ret: [G; OUT_410] = [__v_5];
-        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_396] = [__v_5];
+        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36996,32 +35934,32 @@ fn aiur_fn_410(
   })
 }
 
-const INPUT_SIZE_411: usize = 3;
-const IN_411: usize = 3;
-const OUT_411: usize = 1;
-fn aiur_fn_411(
-  inp: [G; IN_411],
+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_411], 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 __v_2: G = inp[2];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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 = (__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_781] = { let __args: [G; IN_781] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_4]; 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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __v_2, __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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_6, __v_2, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_411] = [__v_8];
-        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_397] = [__v_8];
+        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -37029,8 +35967,8 @@ fn aiur_fn_411(
         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_411] = [__v_9];
-        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_397] = [__v_9];
+        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37040,15 +35978,15 @@ fn aiur_fn_411(
   })
 }
 
-const INPUT_SIZE_412: usize = 3;
-const IN_412: usize = 3;
-const OUT_412: usize = 1;
-fn aiur_fn_412(
-  inp: [G; IN_412],
+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_412], 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];
@@ -37060,90 +35998,90 @@ fn aiur_fn_412(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_1, __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 __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_412] = [__v_7];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_7];
+        record.function_queries[398].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_412] = [__v_9];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_9];
+        record.function_queries[398].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_412] = [__v_9];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_9];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_1, __v_2]; 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_396] = { let __args: [G; IN_396] = [__v_4, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_5, __v_1, __v_2]; 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_396] = { let __args: [G; IN_396] = [__v_5, __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_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_412] = [__v_11];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_11];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_1, __v_2]; 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_396] = { let __args: [G; IN_396] = [__v_4, __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_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_410] = { let __args: [G; IN_410] = [__v_5, __v_1, __v_10]; 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_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __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_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_412] = [__v_13];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_13];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_1, __v_2]; 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_396] = { let __args: [G; IN_396] = [__v_4, __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_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_410] = { let __args: [G; IN_410] = [__v_5, __v_1, __v_10]; 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_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __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_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_412] = [__v_13];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_13];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_5, __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_399] = { let __args: [G; IN_399] = [__v_4, __v_5, __v_6, __v_1, __v_2]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_412] = [__v_7];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_7];
+        record.function_queries[398].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_412] = [__v_9];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_9];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_6, __v_1, __v_2]; 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_396] = { let __args: [G; IN_396] = [__v_6, __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_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_412] = [__v_9];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_9];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37153,15 +36091,15 @@ fn aiur_fn_412(
   })
 }
 
-const INPUT_SIZE_413: usize = 5;
-const IN_413: usize = 5;
-const OUT_413: usize = 1;
-fn aiur_fn_413(
-  inp: [G; IN_413],
+const INPUT_SIZE_399: usize = 5;
+const IN_399: usize = 5;
+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_413], 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];
@@ -37169,30 +36107,30 @@ fn aiur_fn_413(
     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_410] = { let __args: [G; IN_410] = [__v_0, __v_3, __v_4]; 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_396] = { let __args: [G; IN_396] = [__v_0, __v_3, __v_4]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_3, __v_4]; 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_396] = { let __args: [G; IN_396] = [__v_1, __v_3, __v_4]; 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_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_410] = { let __args: [G; IN_410] = [__v_2, __v_3, __v_9]; 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_396] = { let __args: [G; IN_396] = [__v_2, __v_3, __v_9]; 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_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_413] = [__v_11];
-    record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_399] = [__v_11];
+    record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_414: usize = 2;
-const IN_414: usize = 2;
-const OUT_414: usize = 1;
-fn aiur_fn_414(
-  inp: [G; IN_414],
+const INPUT_SIZE_400: usize = 2;
+const IN_400: usize = 2;
+const OUT_400: usize = 1;
+fn aiur_fn_400(
+  inp: [G; IN_400],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_414], 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];
@@ -37202,18 +36140,18 @@ fn aiur_fn_414(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_414] = [__v_0];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_400] = [__v_0];
+        record.function_queries[400].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_414] = { let __args: [G; IN_414] = [__v_7, __v_4]; 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_400] = { let __args: [G; IN_400] = [__v_7, __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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_8];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_400] = [__v_8];
+        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37223,15 +36161,15 @@ fn aiur_fn_414(
   })
 }
 
-const INPUT_SIZE_415: usize = 3;
-const IN_415: usize = 3;
-const OUT_415: usize = 3;
-fn aiur_fn_415(
-  inp: [G; IN_415],
+const INPUT_SIZE_401: usize = 3;
+const IN_401: usize = 3;
+const OUT_401: usize = 3;
+fn aiur_fn_401(
+  inp: [G; IN_401],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_415], 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];
@@ -37251,17 +36189,17 @@ fn aiur_fn_415(
           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_415] = { let __args: [G; IN_415] = [__v_5, __v_9, __v_11]; 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_401] = { let __args: [G; IN_401] = [__v_5, __v_9, __v_11]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
-            let __ret: [G; OUT_415] = [__v_12, __v_13, __v_14];
-            record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_401] = [__v_12, __v_13, __v_14];
+            record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __ret: [G; OUT_415] = [__v_0, __v_2, __v_1];
-            record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_401] = [__v_0, __v_2, __v_1];
+            record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37270,23 +36208,23 @@ fn aiur_fn_415(
         }
       },
       _ => {
-        let __ret: [G; OUT_415] = [__v_0, __v_2, __v_1];
-        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_0, __v_2, __v_1];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_402: usize = 5;
+const IN_402: usize = 5;
+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_416], ExecError> {
+) -> 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];
@@ -37296,56 +36234,56 @@ fn aiur_fn_416(
     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_415] = { let __args: [G; IN_415] = [__v_1, __v_0, __v_7]; 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_401] = { let __args: [G; IN_401] = [__v_1, __v_0, __v_7]; 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_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; 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 __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_414] = { let __args: [G; IN_414] = [__v_1, __v_0]; 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_400] = { let __args: [G; IN_400] = [__v_1, __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_12: G = __r_arr[0];
-        let __ret: [G; OUT_416] = [__v_12];
-        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_402] = [__v_12];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_9, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_9, __v_12]; 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 __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_13, __v_14]; 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_392] = { let __args: [G; IN_392] = [__v_8, __v_13, __v_14]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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_403] = { let __args: [G; IN_403] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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_16: G = __r_arr[0];
-        let __ret: [G; OUT_416] = [__v_16];
-        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_402] = [__v_16];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_8, __v_9, __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 __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_9, __v_12]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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_403] = { let __args: [G; IN_403] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_416] = [__v_14];
-        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_402] = [__v_14];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_417: usize = 5;
-const IN_417: usize = 5;
-const OUT_417: usize = 1;
-fn aiur_fn_417(
-  inp: [G; IN_417],
+const INPUT_SIZE_403: usize = 5;
+const IN_403: usize = 5;
+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_417], 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];
@@ -37359,68 +36297,68 @@ fn aiur_fn_417(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       3u64 => {
-        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 __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_776] = { let __args: [G; IN_776] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_10, __v_1]; 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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_403] = { let __args: [G; IN_403] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_417] = [__v_12];
-        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_403] = [__v_12];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_2, __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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_417] = [__v_9];
-        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; 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_407] = { let __args: [G; IN_407] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_417] = [__v_9];
-        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_7, __v_9]; 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_392] = { let __args: [G; IN_392] = [__v_8, __v_7, __v_9]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_403] = { let __args: [G; IN_403] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_417] = [__v_11];
-        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_403] = [__v_11];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; 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_404] = { let __args: [G; IN_404] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_417] = [__v_9];
-        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; 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_400] = { let __args: [G; IN_400] = [__v_0, __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 __ret: [G; OUT_417] = [__v_9];
-        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_403] = [__v_9];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_418: usize = 7;
-const IN_418: usize = 7;
-const OUT_418: usize = 1;
-fn aiur_fn_418(
-  inp: [G; IN_418],
+const INPUT_SIZE_404: usize = 7;
+const IN_404: usize = 7;
+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_418], 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];
@@ -37429,20 +36367,20 @@ fn aiur_fn_418(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_4, __v_5, __v_6]; 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_414] = { let __args: [G; IN_414] = [__v_2, __v_4, __v_5, __v_6]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7]; 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 __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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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 __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_11, __v_3, __v_4, __v_5, __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 __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_11, __v_3, __v_4, __v_5, __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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_418] = [__v_12];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_404] = [__v_12];
+        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -37453,7 +36391,7 @@ fn aiur_fn_418(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __v_13]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_13]; 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 __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];
@@ -37470,21 +36408,21 @@ fn aiur_fn_418(
             match __v_17.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_28]; 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 __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_9, __v_28]; 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_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_3, __v_4, __v_5, __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 __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_29, __v_3, __v_4, __v_5, __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 __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_418] = [__v_30];
-                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_404] = [__v_30];
+                record.function_queries[404].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_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_414] = { let __args: [G; IN_414] = [__v_29, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_29, __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_30: G = __r_arr[0];
-                let __ret: [G; OUT_418] = [__v_30];
-                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_404] = [__v_30];
+                record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -37492,10 +36430,10 @@ fn aiur_fn_418(
           _ => {
             let __v_16: G = G::from_u64(8);
             let __v_17: G = { let __values: [G; 4] = [__v_16, __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_414] = { let __args: [G; IN_414] = [__v_17, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_17, __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_18: G = __r_arr[0];
-            let __ret: [G; OUT_418] = [__v_18];
-            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_404] = [__v_18];
+            record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -37507,15 +36445,15 @@ fn aiur_fn_418(
   })
 }
 
-const INPUT_SIZE_419: usize = 5;
-const IN_419: usize = 5;
-const OUT_419: usize = 2;
-fn aiur_fn_419(
-  inp: [G; IN_419],
+const INPUT_SIZE_405: usize = 5;
+const IN_405: usize = 5;
+const OUT_405: usize = 2;
+fn aiur_fn_405(
+  inp: [G; IN_405],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_419], 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];
@@ -37529,19 +36467,19 @@ fn aiur_fn_419(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_6]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_6]; 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 __v_9: G = __r_arr[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 __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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_9, __v_10]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __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];
-        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 __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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_9, __v_12]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __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];
-        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 __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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_9, __v_14]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __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 __v_16: G = (__v_13 + __v_15);
         let __v_17: G = (__v_11 + __v_16);
@@ -37552,26 +36490,26 @@ fn aiur_fn_419(
             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_419] = [__v_18, __v_22];
-            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_405] = [__v_18, __v_22];
+            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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];
             match __v_18.as_canonical_u64() {
               2u64 => {
                 let __v_19: G = G::from_u64(0);
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_19]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_19]; 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 __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_20, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_20, __v_2, __v_3, __v_4]; 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_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(1);
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_22]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_22]; 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 __v_23: G = __r_arr[0];
-                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_23, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_23, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_24, __v_4]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_24, __v_4]; 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_25: G = __r_arr[0];
                 let __v_26: G = __r_arr[1];
                 match __v_25.as_canonical_u64() {
@@ -37581,22 +36519,22 @@ fn aiur_fn_419(
                     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_419] = [__v_27, __v_31];
-                    record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_405] = [__v_27, __v_31];
+                    record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_26]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_26]; 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_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_26]; 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 __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_26]; 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_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_28]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_28]; 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_29: G = __r_arr[0];
                     let __v_30: G = (__v_16 * __v_29);
                     let __v_31: G = (__v_27 + __v_30);
                     match __v_31.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_21, __v_4]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_21, __v_4]; 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_32: G = __r_arr[0];
                         let __v_33: G = __r_arr[1];
                         match __v_32.as_canonical_u64() {
@@ -37606,8 +36544,8 @@ fn aiur_fn_419(
                             let __v_36: G = G::from_u64(0);
                             let __v_37: G = G::from_u64(0);
                             let __v_38: G = { let __values: [G; 4] = [__v_35, __v_36, __v_37, __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_419] = [__v_34, __v_38];
-                            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_405] = [__v_34, __v_38];
+                            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -37616,12 +36554,12 @@ fn aiur_fn_419(
                             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_0, __v_21, __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 __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_26]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_26]; 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_39: G = __r_arr[0];
                             let __v_40: G = G::from_u64(0);
                             let __v_41: G = { let __values: [G; 4] = [__v_35, __v_38, __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 __ret: [G; OUT_419] = [__v_34, __v_41];
-                            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_405] = [__v_34, __v_41];
+                            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -37635,8 +36573,8 @@ fn aiur_fn_419(
                         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_419] = [__v_32, __v_36];
-                        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_405] = [__v_32, __v_36];
+                        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -37652,8 +36590,8 @@ fn aiur_fn_419(
                 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_419] = [__v_19, __v_23];
-                record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_405] = [__v_19, __v_23];
+                record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -37666,23 +36604,23 @@ fn aiur_fn_419(
         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_419] = [__v_9, __v_13];
-        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_405] = [__v_9, __v_13];
+        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_420: usize = 7;
-const IN_420: usize = 7;
-const OUT_420: usize = 2;
-fn aiur_fn_420(
-  inp: [G; IN_420],
+const INPUT_SIZE_406: usize = 7;
+const IN_406: usize = 7;
+const OUT_406: usize = 2;
+fn aiur_fn_406(
+  inp: [G; IN_406],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_420], ExecError> {
+) -> 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];
@@ -37691,58 +36629,58 @@ fn aiur_fn_420(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __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 __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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 __v_8: G = __r_arr[1];
     match __v_7.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_420] = [__v_9, __v_8];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_9, __v_8];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_3, __v_6]; 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 __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_6]; 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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         match __v_9.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(1);
-            let __ret: [G; OUT_420] = [__v_11, __v_10];
-            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_406] = [__v_11, __v_10];
+            record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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 __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_420] = [__v_13, __v_12];
-                record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_406] = [__v_13, __v_12];
+                record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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_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(1);
-                    let __ret: [G; OUT_420] = [__v_15, __v_14];
-                    record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_406] = [__v_15, __v_14];
+                    record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_420] = [__v_17, __v_16];
-                        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_406] = [__v_17, __v_16];
+                        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
@@ -37751,8 +36689,8 @@ fn aiur_fn_420(
                         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_420] = [__v_17, __v_21];
-                        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_406] = [__v_17, __v_21];
+                        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -37782,15 +36720,15 @@ fn aiur_fn_420(
   })
 }
 
-const INPUT_SIZE_421: usize = 7;
-const IN_421: usize = 7;
-const OUT_421: usize = 1;
-fn aiur_fn_421(
-  inp: [G; IN_421],
+const INPUT_SIZE_407: usize = 7;
+const IN_407: usize = 7;
+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_421], 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];
@@ -37799,9 +36737,9 @@ fn aiur_fn_421(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_6, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_6, __v_0]; 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 __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_0]; 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 __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];
@@ -37817,22 +36755,22 @@ fn aiur_fn_421(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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[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 __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__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[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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_21, __v_4, __v_5, __v_6]; 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_414] = { let __args: [G; IN_414] = [__v_21, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_22];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_407] = [__v_22];
+            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_2, __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_22: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_22];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_407] = [__v_22];
+            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37841,22 +36779,22 @@ fn aiur_fn_421(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_21, __v_4, __v_5, __v_6]; 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_414] = { let __args: [G; IN_414] = [__v_21, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_22];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_407] = [__v_22];
+            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_2, __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_22: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_22];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_407] = [__v_22];
+            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37865,11 +36803,11 @@ fn aiur_fn_421(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7]; 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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_7]; 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_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_420] = { let __args: [G; IN_420] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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_406] = { let __args: [G; IN_406] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -37888,43 +36826,43 @@ fn aiur_fn_421(
         let __v_22: G = __mc_out___mc_0[1];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_22, __v_4, __v_5, __v_6]; 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_414] = { let __args: [G; IN_414] = [__v_22, __v_4, __v_5, __v_6]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_23];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_407] = [__v_23];
+            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_3, __v_5]; 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 __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_3, __v_5]; 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             match __v_23.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_24, __v_4, __v_5, __v_6]; 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_414] = { let __args: [G; IN_414] = [__v_24, __v_4, __v_5, __v_6]; 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_25: G = __r_arr[0];
-                let __ret: [G; OUT_421] = [__v_25];
-                record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_407] = [__v_25];
+                record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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_405] = { let __args: [G; IN_405] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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_25: G = __r_arr[0];
                     let __v_26: G = __r_arr[1];
                     match __v_25.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_421] = [__v_26];
-                        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_407] = [__v_26];
+                        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_12, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_12, __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_27: G = __r_arr[0];
-                        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __v_4, __v_5, __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 __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_27, __v_3, __v_4, __v_5, __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 __v_28: G = __r_arr[0];
-                        let __ret: [G; OUT_421] = [__v_28];
-                        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_407] = [__v_28];
+                        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -37933,17 +36871,17 @@ fn aiur_fn_421(
                     }
                   },
                   2u64 => {
-                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_2, __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_25: G = __r_arr[0];
-                    let __ret: [G; OUT_421] = [__v_25];
-                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_407] = [__v_25];
+                    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_2, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_2, __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_25: G = __r_arr[0];
-                    let __ret: [G; OUT_421] = [__v_25];
-                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_407] = [__v_25];
+                    record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -37962,15 +36900,15 @@ fn aiur_fn_421(
   })
 }
 
-const INPUT_SIZE_422: usize = 4;
-const IN_422: usize = 4;
-const OUT_422: usize = 1;
-fn aiur_fn_422(
-  inp: [G; IN_422],
+const INPUT_SIZE_408: usize = 4;
+const IN_408: usize = 4;
+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_422], 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];
@@ -37983,79 +36921,79 @@ fn aiur_fn_422(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_422] = [__v_0];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_0];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_422] = [__v_0];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_0];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_422] = [__v_0];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_0];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_422] = [__v_0];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_0];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_422] = [__v_0];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_0];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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 __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_8]; 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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_9, __v_2, __v_3]; 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_409] = { let __args: [G; IN_409] = [__v_0, __v_9, __v_2, __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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_422] = [__v_10];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_10];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_423: usize = 4;
-const IN_423: usize = 4;
-const OUT_423: usize = 1;
-fn aiur_fn_423(
-  inp: [G; IN_423],
+const INPUT_SIZE_409: usize = 4;
+const IN_409: usize = 4;
+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_423], 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 __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 __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_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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_410] = { let __args: [G; IN_410] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
-    let __ret: [G; OUT_423] = [__v_6];
-    record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_409] = [__v_6];
+    record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_424: usize = 5;
-const IN_424: usize = 5;
-const OUT_424: usize = 1;
-fn aiur_fn_424(
-  inp: [G; IN_424],
+const INPUT_SIZE_410: usize = 5;
+const IN_410: usize = 5;
+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_424], ExecError> {
+) -> 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];
@@ -38069,68 +37007,68 @@ fn aiur_fn_424(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       3u64 => {
-        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 __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_776] = { let __args: [G; IN_776] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_10, __v_1]; 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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_410] = { let __args: [G; IN_410] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_424] = [__v_12];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_12];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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_411] = { let __args: [G; IN_411] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_424] = [__v_9];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __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 __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_6, __v_7, __v_0, __v_1, __v_2, __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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_424] = [__v_9];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_7, __v_9]; 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_392] = { let __args: [G; IN_392] = [__v_8, __v_7, __v_9]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_410] = { let __args: [G; IN_410] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_424] = [__v_11];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_11];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; 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_412] = { let __args: [G; IN_412] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __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_9: G = __r_arr[0];
-        let __ret: [G; OUT_424] = [__v_9];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; 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_400] = { let __args: [G; IN_400] = [__v_0, __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 __ret: [G; OUT_424] = [__v_9];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_410] = [__v_9];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_425: usize = 5;
-const IN_425: usize = 5;
-const OUT_425: usize = 1;
-fn aiur_fn_425(
-  inp: [G; IN_425],
+const INPUT_SIZE_411: usize = 5;
+const IN_411: usize = 5;
+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_425], ExecError> {
+) -> 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];
@@ -38140,56 +37078,56 @@ fn aiur_fn_425(
     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_415] = { let __args: [G; IN_415] = [__v_1, __v_0, __v_7]; 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_401] = { let __args: [G; IN_401] = [__v_1, __v_0, __v_7]; 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_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; 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 __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_414] = { let __args: [G; IN_414] = [__v_1, __v_0]; 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_400] = { let __args: [G; IN_400] = [__v_1, __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_12: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_12];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_411] = [__v_12];
+        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_9, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_9, __v_12]; 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 __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_13, __v_14]; 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_392] = { let __args: [G; IN_392] = [__v_8, __v_13, __v_14]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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_410] = { let __args: [G; IN_410] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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_16: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_16];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_411] = [__v_16];
+        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_8, __v_9, __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 __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_9, __v_12]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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_410] = { let __args: [G; IN_410] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_14];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_411] = [__v_14];
+        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_426: usize = 7;
-const IN_426: usize = 7;
-const OUT_426: usize = 1;
-fn aiur_fn_426(
-  inp: [G; IN_426],
+const INPUT_SIZE_412: usize = 7;
+const IN_412: usize = 7;
+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_426], ExecError> {
+) -> 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];
@@ -38198,20 +37136,20 @@ fn aiur_fn_426(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_4, __v_5, __v_6]; 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_408] = { let __args: [G; IN_408] = [__v_2, __v_4, __v_5, __v_6]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7]; 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 __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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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 __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_11, __v_3, __v_4, __v_5, __v_6]; 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_410] = { let __args: [G; IN_410] = [__v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_426] = [__v_12];
-        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_12];
+        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -38222,7 +37160,7 @@ fn aiur_fn_426(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __v_13]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_13]; 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 __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];
@@ -38239,21 +37177,21 @@ fn aiur_fn_426(
             match __v_17.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_28]; 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 __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_9, __v_28]; 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_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_29, __v_3, __v_4, __v_5, __v_6]; 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_410] = { let __args: [G; IN_410] = [__v_29, __v_3, __v_4, __v_5, __v_6]; 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_30: G = __r_arr[0];
-                let __ret: [G; OUT_426] = [__v_30];
-                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_412] = [__v_30];
+                record.function_queries[412].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_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_414] = { let __args: [G; IN_414] = [__v_29, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_29, __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_30: G = __r_arr[0];
-                let __ret: [G; OUT_426] = [__v_30];
-                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_412] = [__v_30];
+                record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -38261,10 +37199,10 @@ fn aiur_fn_426(
           _ => {
             let __v_16: G = G::from_u64(8);
             let __v_17: G = { let __values: [G; 4] = [__v_16, __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_414] = { let __args: [G; IN_414] = [__v_17, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_17, __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_18: G = __r_arr[0];
-            let __ret: [G; OUT_426] = [__v_18];
-            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_412] = [__v_18];
+            record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38276,15 +37214,15 @@ fn aiur_fn_426(
   })
 }
 
-const INPUT_SIZE_427: usize = 7;
-const IN_427: usize = 7;
-const OUT_427: usize = 1;
-fn aiur_fn_427(
-  inp: [G; IN_427],
+const INPUT_SIZE_413: usize = 7;
+const IN_413: usize = 7;
+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_427], 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];
@@ -38293,9 +37231,9 @@ fn aiur_fn_427(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_6, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_6, __v_0]; 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 __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_0]; 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 __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];
@@ -38311,22 +37249,22 @@ fn aiur_fn_427(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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[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 __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__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[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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_21, __v_4, __v_5, __v_6]; 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_408] = { let __args: [G; IN_408] = [__v_21, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_427] = [__v_22];
-            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_413] = [__v_22];
+            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_2, __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_22: G = __r_arr[0];
-            let __ret: [G; OUT_427] = [__v_22];
-            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_413] = [__v_22];
+            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38335,22 +37273,22 @@ fn aiur_fn_427(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_21, __v_4, __v_5, __v_6]; 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_408] = { let __args: [G; IN_408] = [__v_21, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_427] = [__v_22];
-            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_413] = [__v_22];
+            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_2, __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_22: G = __r_arr[0];
-            let __ret: [G; OUT_427] = [__v_22];
-            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_413] = [__v_22];
+            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38359,11 +37297,11 @@ fn aiur_fn_427(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7]; 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 __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_7]; 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_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_420] = { let __args: [G; IN_420] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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_406] = { let __args: [G; IN_406] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -38382,29 +37320,29 @@ fn aiur_fn_427(
         let __v_22: G = __mc_out___mc_0[1];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_22, __v_4, __v_5, __v_6]; 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_408] = { let __args: [G; IN_408] = [__v_22, __v_4, __v_5, __v_6]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_427] = [__v_23];
-            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_413] = [__v_23];
+            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_3, __v_5]; 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 __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_3, __v_5]; 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             match __v_23.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_24, __v_4, __v_5, __v_6]; 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_408] = { let __args: [G; IN_408] = [__v_24, __v_4, __v_5, __v_6]; 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_25: G = __r_arr[0];
-                let __ret: [G; OUT_427] = [__v_25];
-                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_413] = [__v_25];
+                record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_2, __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_25: G = __r_arr[0];
-                let __ret: [G; OUT_427] = [__v_25];
-                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_413] = [__v_25];
+                record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -38421,15 +37359,15 @@ fn aiur_fn_427(
   })
 }
 
-const INPUT_SIZE_428: usize = 4;
-const IN_428: usize = 4;
-const OUT_428: usize = 1;
-fn aiur_fn_428(
-  inp: [G; IN_428],
+const INPUT_SIZE_414: usize = 4;
+const IN_414: usize = 4;
+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_428], 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];
@@ -38442,79 +37380,79 @@ fn aiur_fn_428(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_428] = [__v_0];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_414] = [__v_0];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_428] = [__v_0];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_414] = [__v_0];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_428] = [__v_0];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_414] = [__v_0];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_428] = [__v_0];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_414] = [__v_0];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_428] = [__v_0];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_414] = [__v_0];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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 __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_8]; 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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_9, __v_2, __v_3]; 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 __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_9, __v_2, __v_3]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_428] = [__v_10];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_414] = [__v_10];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_429: usize = 4;
-const IN_429: usize = 4;
-const OUT_429: usize = 1;
-fn aiur_fn_429(
-  inp: [G; IN_429],
+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_429], 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 __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    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 __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_417] = { let __args: [G; IN_417] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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_403] = { let __args: [G; IN_403] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
-    let __ret: [G; OUT_429] = [__v_6];
-    record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_415] = [__v_6];
+    record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_430: usize = 12;
-const IN_430: usize = 12;
-const OUT_430: usize = 2;
-fn aiur_fn_430(
-  inp: [G; IN_430],
+const INPUT_SIZE_416: usize = 12;
+const IN_416: usize = 12;
+const OUT_416: usize = 2;
+fn aiur_fn_416(
+  inp: [G; IN_416],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_430], 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];
@@ -38531,7 +37469,7 @@ fn aiur_fn_430(
     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_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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() {
@@ -38541,21 +37479,21 @@ fn aiur_fn_430(
         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_430] = [__v_17, __v_21];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_416] = [__v_17, __v_21];
+        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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_434] = { let __args: [G; IN_434] = [__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[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 __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__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[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_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_430] = [__v_19, __v_20];
-            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_416] = [__v_19, __v_20];
+            record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38564,8 +37502,8 @@ fn aiur_fn_430(
             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_430] = [__v_19, __v_23];
-            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_416] = [__v_19, __v_23];
+            record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38577,15 +37515,15 @@ fn aiur_fn_430(
   })
 }
 
-const INPUT_SIZE_431: usize = 2;
-const IN_431: usize = 2;
-const OUT_431: usize = 1;
-fn aiur_fn_431(
-  inp: [G; IN_431],
+const INPUT_SIZE_417: usize = 2;
+const IN_417: usize = 2;
+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_431], 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];
@@ -38596,12 +37534,12 @@ fn aiur_fn_431(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       7u64 => {
-        let __ret: [G; OUT_431] = [__v_0];
-        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_0];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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 __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 };
@@ -38611,27 +37549,27 @@ fn aiur_fn_431(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_6, __v_7, __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 __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_7, __v_1]; 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_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_314] = { let __args: [G; IN_314] = [__v_14]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_14]; 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_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_15]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_15]; 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];
                 match __v_16.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_431] = [__v_0];
-                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_417] = [__v_0];
+                    record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13, __v_15, __v_1]; 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 __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_13, __v_15, __v_1]; 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_17: G = __r_arr[0];
-                    let __ret: [G; OUT_431] = [__v_17];
-                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_417] = [__v_17];
+                    record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -38640,15 +37578,15 @@ fn aiur_fn_431(
                 }
               },
               _ => {
-                let __ret: [G; OUT_431] = [__v_0];
-                record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_417] = [__v_0];
+                record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_431] = [__v_0];
-            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_417] = [__v_0];
+            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38657,15 +37595,15 @@ fn aiur_fn_431(
   })
 }
 
-const INPUT_SIZE_432: usize = 3;
-const IN_432: usize = 3;
-const OUT_432: usize = 3;
-fn aiur_fn_432(
-  inp: [G; IN_432],
+const INPUT_SIZE_418: usize = 3;
+const IN_418: usize = 3;
+const OUT_418: usize = 3;
+fn aiur_fn_418(
+  inp: [G; IN_418],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_432], 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];
@@ -38677,11 +37615,11 @@ fn aiur_fn_432(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_4]; 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 __v_7: G = __r_arr[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 __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_7, __v_8]; 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 __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() {
           0u64 => {
@@ -38689,22 +37627,22 @@ fn aiur_fn_432(
             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_432] = [__v_10, __v_0, __v_13];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_418] = [__v_10, __v_0, __v_13];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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_781] = { let __args: [G; IN_781] = [__v_1, __v_13]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_13]; 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 __v_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_15]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_15]; 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 __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];
@@ -38716,8 +37654,8 @@ fn aiur_fn_432(
                     match __v_18.as_canonical_u64() {
                       0u64 => {
                         let __v_21: G = G::from_u64(1);
-                        let __ret: [G; OUT_432] = [__v_21, __v_14, __v_19];
-                        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_418] = [__v_21, __v_14, __v_19];
+                        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -38725,8 +37663,8 @@ fn aiur_fn_432(
                         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_432] = [__v_21, __v_0, __v_24];
-                        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_418] = [__v_21, __v_0, __v_24];
+                        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -38736,8 +37674,8 @@ fn aiur_fn_432(
                     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_432] = [__v_21, __v_0, __v_24];
-                    record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_418] = [__v_21, __v_0, __v_24];
+                    record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -38747,8 +37685,8 @@ fn aiur_fn_432(
                 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_432] = [__v_13, __v_0, __v_16];
-                record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_418] = [__v_13, __v_0, __v_16];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -38763,31 +37701,31 @@ fn aiur_fn_432(
         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_432] = [__v_7, __v_0, __v_10];
-        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_418] = [__v_7, __v_0, __v_10];
+        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_433: usize = 3;
-const IN_433: usize = 3;
-const OUT_433: usize = 1;
-fn aiur_fn_433(
-  inp: [G; IN_433],
+const INPUT_SIZE_419: usize = 3;
+const IN_419: usize = 3;
+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_433], 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 __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 __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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_2, __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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_2, __v_4]; 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 __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
@@ -38795,8 +37733,8 @@ fn aiur_fn_433(
         let __v_7: G = G::from_u64(3);
         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_433] = [__v_9];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_419] = [__v_9];
+        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -38813,9 +37751,9 @@ fn aiur_fn_433(
         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_315] = { let __args: [G; IN_315] = [__v_1, __v_19]; 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 __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_19]; 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_20]; 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 __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_20]; 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_21: G = __r_arr[0];
         let __v_22: G = G::from_u64(2);
         let __v_23: G = G::from_u64(1);
@@ -38823,22 +37761,22 @@ fn aiur_fn_433(
         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_325] = { let __args: [G; IN_325] = [__v_21]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_21]; 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_28: G = __r_arr[0];
         match __v_28.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_433] = [__v_31];
-            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_419] = [__v_31];
+            record.function_queries[419].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 __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_29: G = __r_arr[0];
             let __v_30: G = G::from_u64(0);
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_29, __v_2, __v_30]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_29, __v_2, __v_30]; 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_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
             match __v_31.as_canonical_u64() {
@@ -38846,8 +37784,8 @@ fn aiur_fn_433(
                 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_433] = [__v_35];
-                record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_419] = [__v_35];
+                record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -38870,8 +37808,8 @@ fn aiur_fn_433(
                 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_433] = [__v_51];
-                record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_419] = [__v_51];
+                record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -38891,15 +37829,15 @@ fn aiur_fn_433(
   })
 }
 
-const INPUT_SIZE_434: usize = 11;
-const IN_434: usize = 11;
-const OUT_434: usize = 2;
-fn aiur_fn_434(
-  inp: [G; IN_434],
+const INPUT_SIZE_420: usize = 11;
+const IN_420: usize = 11;
+const OUT_420: usize = 2;
+fn aiur_fn_420(
+  inp: [G; IN_420],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_434], 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];
@@ -38912,22 +37850,22 @@ fn aiur_fn_434(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__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[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 __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__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[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_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_434] = [__v_13, __v_12];
-        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_420] = [__v_13, __v_12];
+        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_5]; 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 __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_443] = { let __args: [G; IN_443] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; 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 __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; 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_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
     match __v_14.as_canonical_u64() {
@@ -38951,17 +37889,17 @@ fn aiur_fn_434(
 }
  };
         let __v_14: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_14, __v_10]; 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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_14, __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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_15, __v_8, __v_9, __v_10]; 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_414] = { let __args: [G; IN_414] = [__v_15, __v_8, __v_9, __v_10]; 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_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_16, __v_10]; 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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_16, __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 __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_17, __v_10]; 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 __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_17, __v_10]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_18, __v_10]; 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 __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_18, __v_10]; 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 __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_19]; 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 __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 };
@@ -38971,7 +37909,7 @@ fn aiur_fn_434(
         let __v_25: G = __loaded[3];
         match __v_22.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_9, __v_23]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_9, __v_23]; 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 __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];
@@ -38987,7 +37925,7 @@ fn aiur_fn_434(
             let __v_37: G = __loaded[10];
             match __v_27.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_6]; 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_770] = { let __args: [G; IN_770] = [__v_6]; 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_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() {
@@ -38997,12 +37935,12 @@ fn aiur_fn_434(
                     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_434] = [__v_40, __v_44];
-                    record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_420] = [__v_40, __v_44];
+                    record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_21]; 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 __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() {
@@ -39012,12 +37950,12 @@ fn aiur_fn_434(
                         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_434] = [__v_42, __v_46];
-                        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_420] = [__v_42, __v_46];
+                        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_6, __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 __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_6, __v_31]; 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 __v_42: G = __r_arr[0];
                         let __v_43: G = __r_arr[1];
                         let __v_44: G = __r_arr[2];
@@ -39025,26 +37963,26 @@ fn aiur_fn_434(
                           _ => {
                             let __v_45: G = (__v_3 + __v_4);
                             let __v_46: G = (__v_2 + __v_45);
-                            let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_1, __v_46]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1, __v_46]; 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 __v_47: G = __r_arr[0];
                             let __v_48: G = (__v_40 - __v_33);
-                            let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_21, __v_48]; 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_769] = { let __args: [G; IN_769] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_799] = { let __args: [G; IN_799] = [__v_1, __v_51]; 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_769] = { let __args: [G; IN_769] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
                             let __v_52: G = __r_arr[0];
-                            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_44, __v_0]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_44, __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_53: G = __r_arr[0];
-                            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_53, __v_47]; 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_400] = { let __args: [G; IN_400] = [__v_53, __v_47]; 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_54: G = __r_arr[0];
-                            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_54, __v_49]; 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_400] = { let __args: [G; IN_400] = [__v_54, __v_49]; 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_55: G = __r_arr[0];
-                            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_55, __v_52]; 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_400] = { let __args: [G; IN_400] = [__v_55, __v_52]; 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_56: G = __r_arr[0];
                             let __v_57: G = G::from_u64(1);
-                            let __ret: [G; OUT_434] = [__v_57, __v_56];
-                            record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_420] = [__v_57, __v_56];
+                            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -39060,21 +37998,21 @@ fn aiur_fn_434(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__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[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 __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__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[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 __v_39: G = __r_arr[1];
-                let __ret: [G; OUT_434] = [__v_38, __v_39];
-                record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_420] = [__v_38, __v_39];
+                record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__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[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 __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__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[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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __ret: [G; OUT_434] = [__v_26, __v_27];
-            record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_420] = [__v_26, __v_27];
+            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -39086,15 +38024,15 @@ fn aiur_fn_434(
   })
 }
 
-const INPUT_SIZE_435: usize = 8;
-const IN_435: usize = 8;
-const OUT_435: usize = 2;
-fn aiur_fn_435(
-  inp: [G; IN_435],
+const INPUT_SIZE_421: usize = 8;
+const IN_421: usize = 8;
+const OUT_421: usize = 2;
+fn aiur_fn_421(
+  inp: [G; IN_421],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_435], 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];
@@ -39113,16 +38051,16 @@ fn aiur_fn_435(
         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_435] = [__v_10, __v_14];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_421] = [__v_10, __v_14];
+        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_4]; 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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_5, __v_6, __v_7]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_11, __v_7]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_11, __v_7]; 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 = __r_arr[1];
         match __v_12.as_canonical_u64() {
@@ -39132,19 +38070,19 @@ fn aiur_fn_435(
             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_435] = [__v_14, __v_18];
-            record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_421] = [__v_14, __v_18];
+            record.function_queries[421].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_781] = { let __args: [G; IN_781] = [__v_0, __v_16]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_16]; 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 __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_17, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_17, __v_5, __v_6, __v_7]; 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_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_18, __v_7]; 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 __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_18, __v_7]; 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_19: G = __r_arr[0];
             match __v_19.as_canonical_u64() {
               0u64 => {
@@ -39153,40 +38091,40 @@ fn aiur_fn_435(
                 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_435] = [__v_20, __v_24];
-                record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_421] = [__v_20, __v_24];
+                record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_14]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_14]; 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 __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_20, __v_5, __v_6, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_5, __v_6, __v_7]; 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_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_799] = { let __args: [G; IN_799] = [__v_0, __v_23]; 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_769] = { let __args: [G; IN_769] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
                 let __v_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_21, __v_7]; 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 __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_21, __v_7]; 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_25: G = __r_arr[0];
                 let __v_26: G = __r_arr[1];
                 match __v_25.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_13]; 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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; 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_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_414] = { let __args: [G; IN_414] = [__v_21, __v_24]; 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_400] = { let __args: [G; IN_400] = [__v_21, __v_24]; 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_29: G = __r_arr[0];
-                        let __ret: [G; OUT_435] = [__v_28, __v_29];
-                        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_421] = [__v_28, __v_29];
+                        record.function_queries[421].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 __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_28: G = __r_arr[0];
                         let __v_29: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_28, __v_7, __v_29]; 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 __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_28, __v_7, __v_29]; 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_30: G = __r_arr[0];
                         let __v_31: G = __r_arr[1];
                         match __v_30.as_canonical_u64() {
@@ -39196,8 +38134,8 @@ fn aiur_fn_435(
                             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_435] = [__v_32, __v_36];
-                            record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_421] = [__v_32, __v_36];
+                            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
@@ -39211,15 +38149,15 @@ fn aiur_fn_435(
                             let __v_39: G = G::from_u64(3);
                             let __v_40: G = G::from_u64(0);
                             let __v_41: G = { let __values: [G; 4] = [__v_39, __v_37, __v_21, __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 __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_13]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_13]; 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_42: G = __r_arr[0];
                             let __v_43: G = G::from_u64(0);
                             let __v_44: G = { let __values: [G; 4] = [__v_38, __v_41, __v_42, __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_45: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_44, __v_24]; 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_400] = { let __args: [G; IN_400] = [__v_44, __v_24]; 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_46: G = __r_arr[0];
-                            let __ret: [G; OUT_435] = [__v_45, __v_46];
-                            record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_421] = [__v_45, __v_46];
+                            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -39234,14 +38172,14 @@ fn aiur_fn_435(
                   },
                   1u64 => {
                     let __v_27: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_26, __v_13]; 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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_26, __v_13]; 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_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_28]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_28]; 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_29: G = __r_arr[0];
-                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_24]; 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_400] = { let __args: [G; IN_400] = [__v_29, __v_24]; 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_30: G = __r_arr[0];
-                    let __ret: [G; OUT_435] = [__v_27, __v_30];
-                    record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_421] = [__v_27, __v_30];
+                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -39266,15 +38204,15 @@ fn aiur_fn_435(
   })
 }
 
-const INPUT_SIZE_436: usize = 2;
-const IN_436: usize = 2;
-const OUT_436: usize = 1;
-fn aiur_fn_436(
-  inp: [G; IN_436],
+const INPUT_SIZE_422: usize = 2;
+const IN_422: usize = 2;
+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_436], 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];
@@ -39292,7 +38230,7 @@ fn aiur_fn_436(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8]; 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 __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 };
@@ -39302,28 +38240,28 @@ fn aiur_fn_436(
             let __v_15: G = __loaded[3];
             match __v_12.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_13]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_13]; 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 __v_16: 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 __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_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16, __v_17]; 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 __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_436] = [__v_19];
-                    record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_422] = [__v_19];
+                    record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_11]; 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 __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_781] = { let __args: [G; IN_781] = [__v_11, __v_22]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_11, __v_22]; 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 __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];
@@ -39333,22 +38271,22 @@ fn aiur_fn_436(
                         match __v_24.as_canonical_u64() {
                           0u64 => {
                             let __v_28: G = G::from_bool((__v_25 == G::ZERO));
-                            let __ret: [G; OUT_436] = [__v_28];
-                            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_422] = [__v_28];
+                            record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_28: G = G::from_u64(0);
-                            let __ret: [G; OUT_436] = [__v_28];
-                            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_422] = [__v_28];
+                            record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_436] = [__v_22];
-                        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_422] = [__v_22];
+                        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -39360,39 +38298,39 @@ fn aiur_fn_436(
               },
               _ => {
                 let __v_16: G = G::from_u64(0);
-                let __ret: [G; OUT_436] = [__v_16];
-                record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_422] = [__v_16];
+                record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_436] = [__v_10];
-            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_422] = [__v_10];
+            record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_436] = [__v_6];
-        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_422] = [__v_6];
+        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_437: usize = 10;
-const IN_437: usize = 10;
-const OUT_437: usize = 2;
-fn aiur_fn_437(
-  inp: [G; IN_437],
+const INPUT_SIZE_423: usize = 10;
+const IN_423: usize = 10;
+const OUT_423: usize = 2;
+fn aiur_fn_423(
+  inp: [G; IN_423],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_437], 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];
@@ -39404,18 +38342,18 @@ fn aiur_fn_437(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_5]; 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_770] = { let __args: [G; IN_770] = [__v_5]; 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_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_793] = { let __args: [G; IN_793] = [__v_5, __v_11]; 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 __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_5, __v_11]; 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 __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_781] = { let __args: [G; IN_781] = [__v_8, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_8, __v_12]; 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 __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];
@@ -39431,7 +38369,7 @@ fn aiur_fn_437(
             let __v_26: G = __loaded[10];
             match __v_16.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_8, __v_19]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_8, __v_19]; 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 __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];
@@ -39447,21 +38385,21 @@ fn aiur_fn_437(
                 let __v_38: G = __loaded[10];
                 match __v_28.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_33]; 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 __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_518] = { let __args: [G; IN_518] = [__v_19, __v_8]; 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_504] = { let __args: [G; IN_504] = [__v_19, __v_8]; 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_40: G = __r_arr[0];
                             match __v_40.as_canonical_u64() {
                               0u64 => {
-                                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_4]; 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 __v_41: G = __r_arr[0];
-                                let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_41, __v_7, __v_8, __v_9]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_41, __v_7, __v_8, __v_9]; 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_42: G = __r_arr[0];
-                                let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_42, __v_7, __v_8, __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 __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_42, __v_7, __v_8, __v_9]; 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_43: G = __r_arr[0];
                                 match __v_43.as_canonical_u64() {
                                   1u64 => {
@@ -39470,31 +38408,31 @@ fn aiur_fn_437(
                                     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_437] = [__v_44, __v_48];
-                                    record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_423] = [__v_44, __v_48];
+                                    record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_14, __v_6]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14, __v_6]; 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_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_795] = { let __args: [G; IN_795] = [__v_0, __v_46]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_0, __v_46]; 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 __v_47: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_44, __v_47]; 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_400] = { let __args: [G; IN_400] = [__v_44, __v_47]; 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_48: G = __r_arr[0];
                                     let __v_49: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_48, __v_19, __v_41, __v_13, __v_49]; 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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_48, __v_19, __v_41, __v_13, __v_49]; 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_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_799] = { let __args: [G; IN_799] = [__v_0, __v_52]; 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_769] = { let __args: [G; IN_769] = [__v_0, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
                                     let __v_53: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_50, __v_53]; 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_400] = { let __args: [G; IN_400] = [__v_50, __v_53]; 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_54: G = __r_arr[0];
                                     let __v_55: G = G::from_u64(1);
-                                    let __ret: [G; OUT_437] = [__v_55, __v_54];
-                                    record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_423] = [__v_55, __v_54];
+                                    record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -39508,8 +38446,8 @@ fn aiur_fn_437(
                                 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_437] = [__v_41, __v_45];
-                                record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_423] = [__v_41, __v_45];
+                                record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -39520,8 +38458,8 @@ fn aiur_fn_437(
                             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_437] = [__v_40, __v_44];
-                            record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_423] = [__v_40, __v_44];
+                            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -39532,8 +38470,8 @@ fn aiur_fn_437(
                         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_437] = [__v_40, __v_44];
-                        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_423] = [__v_40, __v_44];
+                        record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -39556,23 +38494,23 @@ fn aiur_fn_437(
         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_437] = [__v_11, __v_15];
-        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_423] = [__v_11, __v_15];
+        record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_438: usize = 5;
-const IN_438: usize = 5;
-const OUT_438: usize = 2;
-fn aiur_fn_438(
-  inp: [G; IN_438],
+const INPUT_SIZE_424: usize = 5;
+const IN_424: usize = 5;
+const OUT_424: usize = 2;
+fn aiur_fn_424(
+  inp: [G; IN_424],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_438], 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];
@@ -39581,19 +38519,19 @@ fn aiur_fn_438(
     let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       2u64 => {
-        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 __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_438] = [__v_5, __v_6];
-        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_5, __v_6];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_438] = [__v_5, __v_6];
-        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_5, __v_6];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -39602,29 +38540,29 @@ fn aiur_fn_438(
         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_438] = [__v_5, __v_9];
-        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_5, __v_9];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_439: usize = 4;
-const IN_439: usize = 4;
-const OUT_439: usize = 2;
-fn aiur_fn_439(
-  inp: [G; IN_439],
+const INPUT_SIZE_425: usize = 4;
+const IN_425: usize = 4;
+const OUT_425: usize = 2;
+fn aiur_fn_425(
+  inp: [G; IN_425],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_439], 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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 };
@@ -39635,33 +38573,33 @@ fn aiur_fn_439(
         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_439] = [__v_7, __v_11];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_425] = [__v_7, __v_11];
+        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_7]; 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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(5);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_9]; 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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_10, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_10, __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_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_799] = { let __args: [G; IN_799] = [__v_0, __v_13]; 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_769] = { let __args: [G; IN_769] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_17, __v_14]; 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_400] = { let __args: [G; IN_400] = [__v_17, __v_14]; 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_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_439] = [__v_19, __v_18];
-            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_425] = [__v_19, __v_18];
+            record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -39670,8 +38608,8 @@ fn aiur_fn_439(
             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_439] = [__v_13, __v_17];
-            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_425] = [__v_13, __v_17];
+            record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -39686,21 +38624,21 @@ fn aiur_fn_439(
   })
 }
 
-const INPUT_SIZE_440: usize = 4;
-const IN_440: usize = 4;
-const OUT_440: usize = 2;
-fn aiur_fn_440(
-  inp: [G; IN_440],
+const INPUT_SIZE_426: usize = 4;
+const IN_426: usize = 4;
+const OUT_426: usize = 2;
+fn aiur_fn_426(
+  inp: [G; IN_426],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_440], 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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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 };
@@ -39711,33 +38649,33 @@ fn aiur_fn_440(
         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_440] = [__v_7, __v_11];
-        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_426] = [__v_7, __v_11];
+        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_7]; 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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(4);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_9]; 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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_10, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_10, __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_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_799] = { let __args: [G; IN_799] = [__v_0, __v_13]; 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_769] = { let __args: [G; IN_769] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_17, __v_14]; 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_400] = { let __args: [G; IN_400] = [__v_17, __v_14]; 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_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_440] = [__v_19, __v_18];
-            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_426] = [__v_19, __v_18];
+            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -39746,8 +38684,8 @@ fn aiur_fn_440(
             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_440] = [__v_13, __v_17];
-            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_426] = [__v_13, __v_17];
+            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -39762,23 +38700,23 @@ fn aiur_fn_440(
   })
 }
 
-const INPUT_SIZE_441: usize = 4;
-const IN_441: usize = 4;
-const OUT_441: usize = 2;
-fn aiur_fn_441(
-  inp: [G; IN_441],
+const INPUT_SIZE_427: usize = 4;
+const IN_427: usize = 4;
+const OUT_427: usize = 2;
+fn aiur_fn_427(
+  inp: [G; IN_427],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_441], 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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_1, __v_2, __v_3]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_4]; 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 __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 };
@@ -39788,7 +38726,7 @@ fn aiur_fn_441(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_8]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_8]; 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 __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];
@@ -39806,18 +38744,18 @@ fn aiur_fn_441(
           4u64 => {
             match __v_15.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; 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 __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() {
                   0u64 => {
                     let __v_26: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_6, __v_26]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_6, __v_26]; 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 __v_27: G = __r_arr[0];
                     let __v_28: G = G::from_u64(1);
-                    let __ret: [G; OUT_441] = [__v_28, __v_27];
-                    record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_427] = [__v_28, __v_27];
+                    record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -39826,8 +38764,8 @@ fn aiur_fn_441(
                     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_441] = [__v_26, __v_30];
-                    record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_427] = [__v_26, __v_30];
+                    record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -39838,8 +38776,8 @@ fn aiur_fn_441(
                 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_441] = [__v_23, __v_27];
-                record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_427] = [__v_23, __v_27];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -39850,8 +38788,8 @@ fn aiur_fn_441(
             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_441] = [__v_23, __v_27];
-            record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_427] = [__v_23, __v_27];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -39862,23 +38800,23 @@ fn aiur_fn_441(
         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_441] = [__v_11, __v_15];
-        record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_427] = [__v_11, __v_15];
+        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_442: usize = 5;
-const IN_442: usize = 5;
-const OUT_442: usize = 1;
-fn aiur_fn_442(
-  inp: [G; IN_442],
+const INPUT_SIZE_428: usize = 5;
+const IN_428: usize = 5;
+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_442], 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];
@@ -39888,8 +38826,8 @@ fn aiur_fn_442(
     let __v_5: G = (__v_3 - __v_4);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_442] = [__v_0];
-        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_428] = [__v_0];
+        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -39900,25 +38838,25 @@ fn aiur_fn_442(
         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_442] = { let __args: [G; IN_442] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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_13: G = __r_arr[0];
-        let __ret: [G; OUT_442] = [__v_13];
-        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_428] = [__v_13];
+        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_443: usize = 6;
-const IN_443: usize = 6;
-const OUT_443: usize = 2;
-fn aiur_fn_443(
-  inp: [G; IN_443],
+const INPUT_SIZE_429: usize = 6;
+const IN_429: usize = 6;
+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_443], 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];
@@ -39939,14 +38877,14 @@ fn aiur_fn_443(
         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_443] = [__v_11, __v_15];
-        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_429] = [__v_11, __v_15];
+        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_7]; 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 __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];
@@ -39962,7 +38900,7 @@ fn aiur_fn_443(
             let __v_22: G = __loaded[10];
             match __v_12.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_15]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_15]; 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 __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];
@@ -39978,7 +38916,7 @@ fn aiur_fn_443(
                 let __v_34: G = __loaded[10];
                 match __v_24.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_29]; 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 __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 => {
@@ -39987,19 +38925,19 @@ fn aiur_fn_443(
                         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_443] = [__v_36, __v_40];
-                        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_429] = [__v_36, __v_40];
+                        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_36: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_29, __v_36]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_29, __v_36]; 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 __v_37: G = __r_arr[0];
-                        let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_3, __v_4, __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_38: G = __r_arr[0];
-                        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_38, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_38, __v_3, __v_4, __v_5]; 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_39: G = __r_arr[0];
-                        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_39]; 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 __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 };
@@ -40015,19 +38953,19 @@ fn aiur_fn_443(
                                 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_795] = { let __args: [G; IN_795] = [__v_41, __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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_41, __v_1]; 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 __v_50: G = __r_arr[0];
-                                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_49, __v_50]; 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_400] = { let __args: [G; IN_400] = [__v_49, __v_50]; 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_51: G = __r_arr[0];
-                                let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_51, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_51, __v_3, __v_4, __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_52: G = __r_arr[0];
-                                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_39, __v_52, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_39, __v_52, __v_3, __v_4, __v_5]; 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_53: G = __r_arr[0];
                                 match __v_53.as_canonical_u64() {
                                   1u64 => {
                                     let __v_54: G = G::from_u64(1);
-                                    let __ret: [G; OUT_443] = [__v_54, __v_51];
-                                    record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_429] = [__v_54, __v_51];
+                                    record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
@@ -40036,8 +38974,8 @@ fn aiur_fn_443(
                                     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_443] = [__v_54, __v_58];
-                                    record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_429] = [__v_54, __v_58];
+                                    record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -40051,8 +38989,8 @@ fn aiur_fn_443(
                                 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_443] = [__v_47, __v_51];
-                                record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_429] = [__v_47, __v_51];
+                                record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -40063,8 +39001,8 @@ fn aiur_fn_443(
                             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_443] = [__v_46, __v_50];
-                            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_429] = [__v_46, __v_50];
+                            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -40090,15 +39028,15 @@ fn aiur_fn_443(
   })
 }
 
-const INPUT_SIZE_444: usize = 2;
-const IN_444: usize = 2;
-const OUT_444: usize = 1;
-fn aiur_fn_444(
-  inp: [G; IN_444],
+const INPUT_SIZE_430: usize = 2;
+const IN_430: usize = 2;
+const OUT_430: usize = 1;
+fn aiur_fn_430(
+  inp: [G; IN_430],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_444], 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];
@@ -40112,24 +39050,24 @@ fn aiur_fn_444(
         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_444] = [__v_8];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_430] = [__v_8];
+        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_444] = [__v_3];
-            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_430] = [__v_3];
+            record.function_queries[430].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_444] = { let __args: [G; IN_444] = [__v_4, __v_6]; 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 __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_4, __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 __ret: [G; OUT_444] = [__v_7];
-            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_430] = [__v_7];
+            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40141,15 +39079,15 @@ fn aiur_fn_444(
   })
 }
 
-const INPUT_SIZE_445: usize = 1;
-const IN_445: usize = 1;
-const OUT_445: usize = 2;
-fn aiur_fn_445(
-  inp: [G; IN_445],
+const INPUT_SIZE_431: usize = 1;
+const IN_431: usize = 1;
+const OUT_431: usize = 2;
+fn aiur_fn_431(
+  inp: [G; IN_431],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_445], ExecError> {
+) -> Result<[G; OUT_431], 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 };
@@ -40160,8 +39098,8 @@ fn aiur_fn_445(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_445] = [__v_5, __v_2];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_431] = [__v_5, __v_2];
+        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40169,23 +39107,23 @@ fn aiur_fn_445(
         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_445] = [__v_5, __v_8];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_431] = [__v_5, __v_8];
+        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_446: usize = 1;
-const IN_446: usize = 1;
-const OUT_446: usize = 3;
-fn aiur_fn_446(
-  inp: [G; IN_446],
+const INPUT_SIZE_432: usize = 1;
+const IN_432: usize = 1;
+const OUT_432: usize = 3;
+fn aiur_fn_432(
+  inp: [G; IN_432],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_446], ExecError> {
+) -> Result<[G; OUT_432], 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 };
@@ -40196,8 +39134,8 @@ fn aiur_fn_446(
     match __v_1.as_canonical_u64() {
       5u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_446] = [__v_5, __v_2, __v_3];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_432] = [__v_5, __v_2, __v_3];
+        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40210,23 +39148,23 @@ fn aiur_fn_446(
         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_446] = [__v_5, __v_9, __v_13];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_432] = [__v_5, __v_9, __v_13];
+        record.function_queries[432].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_433: usize = 2;
+const IN_433: usize = 2;
+const OUT_433: usize = 1;
+fn aiur_fn_433(
+  inp: [G; IN_433],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_447], 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];
@@ -40240,8 +39178,8 @@ fn aiur_fn_447(
         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_447] = [__v_8];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_433] = [__v_8];
+        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -40249,23 +39187,23 @@ fn aiur_fn_447(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_5, __v_6]; 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_386] = { let __args: [G; IN_386] = [__v_3, __v_5, __v_6]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_447] = [__v_7];
-            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_433] = [__v_7];
+            record.function_queries[433].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_447] = { let __args: [G; IN_447] = [__v_4, __v_6]; 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 __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_4, __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 __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_7, __v_8, __v_9]; 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_386] = { let __args: [G; IN_386] = [__v_7, __v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_447] = [__v_10];
-            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_433] = [__v_10];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40277,41 +39215,41 @@ fn aiur_fn_447(
   })
 }
 
-const INPUT_SIZE_448: usize = 4;
-const IN_448: usize = 4;
-const OUT_448: usize = 1;
-fn aiur_fn_448(
-  inp: [G; IN_448],
+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_448], 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 __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_5, __v_2, __v_3]; 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 __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_5, __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_448] = [__v_6];
-    record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_434] = [__v_6];
+    record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_449: usize = 4;
-const IN_449: usize = 4;
-const OUT_449: usize = 1;
-fn aiur_fn_449(
-  inp: [G; IN_449],
+const INPUT_SIZE_435: usize = 4;
+const IN_435: usize = 4;
+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_449], 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];
@@ -40324,10 +39262,10 @@ fn aiur_fn_449(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_5]; 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 __ret: [G; OUT_449] = [__v_8];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_8];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -40335,16 +39273,16 @@ fn aiur_fn_449(
         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_232] = { let __args: [G; IN_232] = [__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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_11]; 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_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_449] = [__v_14];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_14];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_5]; 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 __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];
@@ -40358,85 +39296,85 @@ fn aiur_fn_449(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__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[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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__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[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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; 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 __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_459] = { let __args: [G; IN_459] = [__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[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 __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__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[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_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_235] = { let __args: [G; IN_235] = [__v_22, __v_6]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_22, __v_6]; 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_23: G = __r_arr[0];
-        let __ret: [G; OUT_449] = [__v_23];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_23];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        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 __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_448] = { let __args: [G; IN_448] = [__v_8, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_8, __v_1, __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 __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_453] = { let __args: [G; IN_453] = [__v_10, __v_9, __v_13, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_10, __v_9, __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_14: G = __r_arr[0];
-        let __ret: [G; OUT_449] = [__v_14];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_14];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_1, __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_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_448] = { let __args: [G; IN_448] = [__v_6, __v_10, __v_2, __v_3]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_10, __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_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_449] = [__v_14];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_14];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_1, __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_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_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_10, __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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_8, __v_11]; 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 __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8, __v_11]; 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_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_449] = [__v_15];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_15];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __v_6, __v_7, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_5, __v_6, __v_7, __v_1, __v_2, __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_8: G = __r_arr[0];
-        let __ret: [G; OUT_449] = [__v_8];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_8];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_5, __v_6, __v_3]; 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 __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_5, __v_6, __v_3]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_449] = [__v_8];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_8];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_6, __v_7, __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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_6, __v_7, __v_1, __v_2, __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_8: G = __r_arr[0];
-        let __ret: [G; OUT_449] = [__v_8];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_8];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40446,15 +39384,15 @@ fn aiur_fn_449(
   })
 }
 
-const INPUT_SIZE_450: usize = 6;
-const IN_450: usize = 6;
-const OUT_450: usize = 1;
-fn aiur_fn_450(
-  inp: [G; IN_450],
+const INPUT_SIZE_436: usize = 6;
+const IN_436: usize = 6;
+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_450], 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];
@@ -40462,46 +39400,46 @@ fn aiur_fn_450(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_3, __v_4, __v_5]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_1, __v_0, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_0, __v_3, __v_4, __v_5]; 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_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_2, __v_1, __v_7]; 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_392] = { let __args: [G; IN_392] = [__v_2, __v_1, __v_7]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_8, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_8, __v_3, __v_4, __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_9: G = __r_arr[0];
-    let __ret: [G; OUT_450] = [__v_9];
-    record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_436] = [__v_9];
+    record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_451: usize = 3;
-const IN_451: usize = 3;
-const OUT_451: usize = 1;
-fn aiur_fn_451(
-  inp: [G; IN_451],
+const INPUT_SIZE_437: usize = 3;
+const IN_437: usize = 3;
+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_451], 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];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_2]; 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_453] = { let __args: [G; IN_453] = [__v_2]; 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_3: G = __r_arr[0];
-        let __ret: [G; OUT_451] = [__v_3];
-        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_437] = [__v_3];
+        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_2]; 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 __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_2]; 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_3: G = __r_arr[0];
-        let __ret: [G; OUT_451] = [__v_3];
-        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_437] = [__v_3];
+        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40511,15 +39449,15 @@ fn aiur_fn_451(
   })
 }
 
-const INPUT_SIZE_452: usize = 6;
-const IN_452: usize = 6;
-const OUT_452: usize = 1;
-fn aiur_fn_452(
-  inp: [G; IN_452],
+const INPUT_SIZE_438: usize = 6;
+const IN_438: usize = 6;
+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_452], 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];
@@ -40527,11 +39465,11 @@ fn aiur_fn_452(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_2, __v_3, __v_4, __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_6, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_6, __v_3, __v_4, __v_5]; 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7]; 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 __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 };
@@ -40541,7 +39479,7 @@ fn aiur_fn_452(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_11]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_11]; 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 __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];
@@ -40561,12 +39499,12 @@ fn aiur_fn_452(
         match __v_15.as_canonical_u64() {
           5u64 => {
             let __v_26: G = (__v_18 + __v_19);
-            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_17, __v_12, __v_26, __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 __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_17, __v_12, __v_26, __v_3, __v_4, __v_5]; 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_27: G = __r_arr[0];
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_20, __v_28]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_20, __v_28]; 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 __v_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_29]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_29]; 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 __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];
@@ -40580,7 +39518,7 @@ fn aiur_fn_452(
             let __v_39: G = __loaded[8];
             let __v_40: G = __loaded[9];
             let __v_41: G = __loaded[10];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_20]; 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 __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) {
@@ -40588,15 +39526,15 @@ fn aiur_fn_452(
             }
             match __v_31.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_33, __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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_33, __v_12]; 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_44: G = __r_arr[0];
-                let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_44, __v_9, __v_18]; 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 __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_44, __v_9, __v_18]; 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_45: G = __r_arr[0];
                 let __v_46: G = G::from_u64(0);
-                let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__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[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 __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__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[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_47: G = __r_arr[0];
-                let __ret: [G; OUT_452] = [__v_47];
-                record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_438] = [__v_47];
+                record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -40616,15 +39554,15 @@ fn aiur_fn_452(
   })
 }
 
-const INPUT_SIZE_453: usize = 6;
-const IN_453: usize = 6;
-const OUT_453: usize = 1;
-fn aiur_fn_453(
-  inp: [G; IN_453],
+const INPUT_SIZE_439: usize = 6;
+const IN_439: usize = 6;
+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_453], 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];
@@ -40639,10 +39577,10 @@ fn aiur_fn_453(
     match __v_6.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_2, __v_9]; 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_396] = { let __args: [G; IN_396] = [__v_0, __v_2, __v_9]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_453] = [__v_10];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_439] = [__v_10];
+        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -40654,28 +39592,28 @@ fn aiur_fn_453(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_2, __v_13]; 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_396] = { let __args: [G; IN_396] = [__v_10, __v_2, __v_13]; 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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_14, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_7, __v_14, __v_3, __v_4, __v_5]; 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_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_453] = { let __args: [G; IN_453] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_11, __v_8, __v_16, __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_17: G = __r_arr[0];
-            let __ret: [G; OUT_453] = [__v_17];
-            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_439] = [__v_17];
+            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_2, __v_13]; 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_396] = { let __args: [G; IN_396] = [__v_0, __v_2, __v_13]; 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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_14, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_14, __v_3, __v_4, __v_5]; 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_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_15]; 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 __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_15]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             let __v_18: G = __r_arr[2];
-            let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_17, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_7, __v_17, __v_3, __v_4, __v_5]; 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_19: G = G::from_u64(0);
             let __v_20: G = G::from_u64(1);
             let __v_21: G = G::from_u64(1);
@@ -40685,10 +39623,10 @@ fn aiur_fn_453(
             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_453] = { let __args: [G; IN_453] = [__v_18, __v_8, __v_23, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_18, __v_8, __v_23, __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_25: G = __r_arr[0];
-            let __ret: [G; OUT_453] = [__v_25];
-            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_439] = [__v_25];
+            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40700,21 +39638,21 @@ fn aiur_fn_453(
   })
 }
 
-const INPUT_SIZE_454: usize = 4;
-const IN_454: usize = 4;
-const OUT_454: usize = 1;
-fn aiur_fn_454(
-  inp: [G; IN_454],
+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_454], 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];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_1, __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 __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];
@@ -40723,92 +39661,92 @@ fn aiur_fn_454(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_454] = [__v_6];
-        record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_440] = [__v_6];
+        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_4, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_9]; 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 __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9]; 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_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_454] = [__v_11];
-        record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_440] = [__v_11];
+        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_455: usize = 5;
-const IN_455: usize = 5;
-const OUT_455: usize = 0;
-fn aiur_fn_455(
-  inp: [G; IN_455],
+const INPUT_SIZE_441: usize = 5;
+const IN_441: usize = 5;
+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_455], ExecError> {
+) -> 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 __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_2, __v_3, __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_470] = { let __args: [G; IN_470] = [__v_5, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_1, __v_2, __v_3, __v_4]; 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_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_455] = [];
-    record.function_queries[455].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);
   })
 }
 
-const INPUT_SIZE_456: usize = 4;
-const IN_456: usize = 4;
-const OUT_456: usize = 1;
-fn aiur_fn_456(
-  inp: [G; IN_456],
+const INPUT_SIZE_442: usize = 4;
+const IN_442: usize = 4;
+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_456], 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 __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_5, __v_2, __v_3]; 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 __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_5, __v_2, __v_3]; 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_456] = [__v_6];
-    record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_442] = [__v_6];
+    record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_457: usize = 4;
-const IN_457: usize = 4;
-const OUT_457: usize = 1;
-fn aiur_fn_457(
-  inp: [G; IN_457],
+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_457], 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];
@@ -40821,10 +39759,10 @@ fn aiur_fn_457(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_5]; 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 __ret: [G; OUT_457] = [__v_8];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_8];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -40832,16 +39770,16 @@ fn aiur_fn_457(
         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_232] = { let __args: [G; IN_232] = [__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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_11]; 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_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_457] = [__v_14];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_14];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_5]; 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 __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];
@@ -40855,23 +39793,23 @@ fn aiur_fn_457(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__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[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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__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[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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; 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 __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_459] = { let __args: [G; IN_459] = [__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[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 __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__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[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_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_235] = { let __args: [G; IN_235] = [__v_22, __v_6]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_22, __v_6]; 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_23: G = __r_arr[0];
-        let __ret: [G; OUT_457] = [__v_23];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_23];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_1, __v_2, __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_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];
@@ -40881,16 +39819,16 @@ fn aiur_fn_457(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_11, __v_6, __v_13]; 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_392] = { let __args: [G; IN_392] = [__v_11, __v_6, __v_13]; 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_14: G = __r_arr[0];
-            let __ret: [G; OUT_457] = [__v_14];
-            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_443] = [__v_14];
+            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_8, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_8, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_13]; 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 __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
@@ -40899,10 +39837,10 @@ fn aiur_fn_457(
               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_406] = { let __args: [G; IN_406] = [__v_16, __v_6, __v_18]; 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_392] = { let __args: [G; IN_392] = [__v_16, __v_6, __v_18]; 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_19: G = __r_arr[0];
-            let __ret: [G; OUT_457] = [__v_19];
-            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_443] = [__v_19];
+            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40910,55 +39848,55 @@ fn aiur_fn_457(
       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_456] = { let __args: [G; IN_456] = [__v_6, __v_9, __v_2, __v_3]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_6, __v_9, __v_2, __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_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_457] = [__v_13];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_13];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_1, __v_2, __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_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_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_6, __v_10, __v_2, __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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_8, __v_11]; 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 __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8, __v_11]; 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_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_457] = [__v_15];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_15];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_7, __v_6, __v_8]; 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_392] = { let __args: [G; IN_392] = [__v_7, __v_6, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_9, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_9, __v_1, __v_2, __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_10: G = __r_arr[0];
-        let __ret: [G; OUT_457] = [__v_10];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_10];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__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 __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_3]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_457] = [__v_8];
-            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_443] = [__v_8];
+            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__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 __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_3]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_457] = [__v_8];
-            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_443] = [__v_8];
+            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -40967,11 +39905,11 @@ fn aiur_fn_457(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7, __v_1, __v_2, __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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_8, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_8, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9]; 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 __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 };
@@ -40981,7 +39919,7 @@ fn aiur_fn_457(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_13]; 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 __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];
@@ -41001,12 +39939,12 @@ fn aiur_fn_457(
             match __v_17.as_canonical_u64() {
               5u64 => {
                 let __v_28: G = (__v_20 + __v_21);
-                let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_19, __v_14, __v_28, __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 __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_19, __v_14, __v_28, __v_1, __v_2, __v_3]; 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_29: G = __r_arr[0];
                 let __v_30: G = G::from_u64(0);
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_22, __v_30]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_22, __v_30]; 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 __v_31: G = __r_arr[0];
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_31]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_31]; 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 __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];
@@ -41020,7 +39958,7 @@ fn aiur_fn_457(
                 let __v_41: G = __loaded[8];
                 let __v_42: G = __loaded[9];
                 let __v_43: G = __loaded[10];
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_22]; 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 __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) {
@@ -41028,15 +39966,15 @@ fn aiur_fn_457(
                 }
                 match __v_33.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_35, __v_14]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_35, __v_14]; 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_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_46, __v_11, __v_20]; 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 __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_46, __v_11, __v_20]; 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_47: G = __r_arr[0];
                     let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__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[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 __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__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[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_49: G = __r_arr[0];
-                    let __ret: [G; OUT_457] = [__v_49];
-                    record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_443] = [__v_49];
+                    record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -41061,21 +39999,21 @@ fn aiur_fn_457(
   })
 }
 
-const INPUT_SIZE_458: usize = 4;
-const IN_458: usize = 4;
-const OUT_458: usize = 1;
-fn aiur_fn_458(
-  inp: [G; IN_458],
+const INPUT_SIZE_444: usize = 4;
+const IN_444: usize = 4;
+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_458], 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2, __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_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];
@@ -41084,37 +40022,37 @@ fn aiur_fn_458(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_458] = [__v_6];
-        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_444] = [__v_6];
+        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_4, __v_1, __v_2, __v_3]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_9]; 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 __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9]; 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_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_458] = [__v_11];
-        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_444] = [__v_11];
+        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_459: usize = 11;
-const IN_459: usize = 11;
-const OUT_459: usize = 1;
-fn aiur_fn_459(
-  inp: [G; IN_459],
+const INPUT_SIZE_445: usize = 11;
+const IN_445: usize = 11;
+const OUT_445: usize = 1;
+fn aiur_fn_445(
+  inp: [G; IN_445],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_459], 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];
@@ -41129,43 +40067,43 @@ fn aiur_fn_459(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_459] = [__v_2];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41175,15 +40113,15 @@ fn aiur_fn_459(
   })
 }
 
-const INPUT_SIZE_460: usize = 11;
-const IN_460: usize = 11;
-const OUT_460: usize = 1;
-fn aiur_fn_460(
-  inp: [G; IN_460],
+const INPUT_SIZE_446: usize = 11;
+const IN_446: usize = 11;
+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_460], 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];
@@ -41198,43 +40136,43 @@ fn aiur_fn_460(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_460] = [__v_1];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_1];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41244,23 +40182,23 @@ fn aiur_fn_460(
   })
 }
 
-const INPUT_SIZE_461: usize = 3;
-const IN_461: usize = 3;
-const OUT_461: usize = 1;
-fn aiur_fn_461(
-  inp: [G; IN_461],
+const INPUT_SIZE_447: usize = 3;
+const IN_447: usize = 3;
+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_461], 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];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_461] = [__v_0];
-        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_0];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41278,14 +40216,14 @@ fn aiur_fn_461(
             match __v_7.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __v_8, __v_10]; 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_392] = { let __args: [G; IN_392] = [__v_5, __v_8, __v_10]; 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_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_461] = { let __args: [G; IN_461] = [__v_11, __v_9, __v_13]; 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 __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_11, __v_9, __v_13]; 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_14: G = __r_arr[0];
-                let __ret: [G; OUT_461] = [__v_14];
-                record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_447] = [__v_14];
+                record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -41302,15 +40240,15 @@ fn aiur_fn_461(
   })
 }
 
-const INPUT_SIZE_462: usize = 9;
-const IN_462: usize = 9;
-const OUT_462: usize = 1;
-fn aiur_fn_462(
-  inp: [G; IN_462],
+const INPUT_SIZE_448: usize = 9;
+const IN_448: usize = 9;
+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_462], 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];
@@ -41331,24 +40269,24 @@ fn aiur_fn_462(
         let __v_13: G = (__v_1 - __v_2);
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_5, __v_10, __v_6, __v_7, __v_8]; 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_462] = [__v_10];
-            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_10, __v_6, __v_7, __v_8]; 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 __ret: [G; OUT_448] = [__v_10];
+            record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; 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 __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; 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_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_406] = { let __args: [G; IN_406] = [__v_11, __v_15, __v_16]; 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_392] = { let __args: [G; IN_392] = [__v_11, __v_15, __v_16]; 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_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_462] = { let __args: [G; IN_462] = [__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[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 __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__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[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_20: G = __r_arr[0];
-            let __ret: [G; OUT_462] = [__v_20];
-            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_448] = [__v_20];
+            record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41360,15 +40298,15 @@ fn aiur_fn_462(
   })
 }
 
-const INPUT_SIZE_463: usize = 6;
-const IN_463: usize = 6;
-const OUT_463: usize = 0;
-fn aiur_fn_463(
-  inp: [G; IN_463],
+const INPUT_SIZE_449: usize = 6;
+const IN_449: usize = 6;
+const OUT_449: usize = 0;
+fn aiur_fn_449(
+  inp: [G; IN_449],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_463], 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];
@@ -41378,33 +40316,33 @@ fn aiur_fn_463(
     let __v_5: G = inp[5];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_463] = [];
-        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_1, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_3, __v_4, __v_5]; 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_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_229] = { let __args: [G; IN_229] = [__v_6, __v_9]; 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 __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() {
           1u64 => {
-            let __ret: [G; OUT_463] = [];
-            record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_449] = [];
+            record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_2]; 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_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() });
             }
-            let __ret: [G; OUT_463] = [];
-            record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_449] = [];
+            record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41413,15 +40351,15 @@ fn aiur_fn_463(
   })
 }
 
-const INPUT_SIZE_464: usize = 5;
-const IN_464: usize = 5;
-const OUT_464: usize = 1;
-fn aiur_fn_464(
-  inp: [G; IN_464],
+const INPUT_SIZE_450: usize = 5;
+const IN_450: usize = 5;
+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_464], 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];
@@ -41430,14 +40368,14 @@ fn aiur_fn_464(
     let __v_4: G = inp[4];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_464] = [__v_5];
-        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_450] = [__v_5];
+        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_2, __v_3, __v_4]; 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_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];
@@ -41448,15 +40386,15 @@ fn aiur_fn_464(
           5u64 => {
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_8, __v_11, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_8, __v_11, __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_12: G = __r_arr[0];
-            let __ret: [G; OUT_464] = [__v_12];
-            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_450] = [__v_12];
+            record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_464] = [__v_5];
-            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_450] = [__v_5];
+            record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41465,15 +40403,15 @@ fn aiur_fn_464(
   })
 }
 
-const INPUT_SIZE_465: usize = 6;
-const IN_465: usize = 6;
-const OUT_465: usize = 1;
-fn aiur_fn_465(
-  inp: [G; IN_465],
+const INPUT_SIZE_451: usize = 6;
+const IN_451: usize = 6;
+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_465], ExecError> {
+) -> Result<[G; OUT_451], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41481,9 +40419,9 @@ fn aiur_fn_465(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_6, __v_2, __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 __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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_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];
@@ -41495,31 +40433,31 @@ fn aiur_fn_465(
         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_229] = { let __args: [G; IN_229] = [__v_9, __v_14]; 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 __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_465] = [__v_15];
-        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_451] = [__v_15];
+        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_465] = [__v_12];
-        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_451] = [__v_12];
+        record.function_queries[451].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],
+const INPUT_SIZE_452: usize = 5;
+const IN_452: usize = 5;
+const OUT_452: usize = 0;
+fn aiur_fn_452(
+  inp: [G; IN_452],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_466], ExecError> {
+) -> Result<[G; OUT_452], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41528,45 +40466,45 @@ fn aiur_fn_466(
     let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_466] = [];
-        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_452] = [];
+        record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; 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_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_229] = { let __args: [G; IN_229] = [__v_5, __v_8]; 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 __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_466] = [];
-        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_452] = [];
+        record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_467: usize = 1;
-const IN_467: usize = 1;
-const OUT_467: usize = 1;
-fn aiur_fn_467(
-  inp: [G; IN_467],
+const INPUT_SIZE_453: usize = 1;
+const IN_453: usize = 1;
+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_467], ExecError> {
+) -> Result<[G; OUT_453], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[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 __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_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_0, __v_2]; 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 __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_1, __v_0, __v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(2);
     let __v_5: G = G::from_u64(1);
@@ -41574,27 +40512,27 @@ fn aiur_fn_467(
     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_467] = [__v_9];
-    record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_453] = [__v_9];
+    record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_468: usize = 1;
-const IN_468: usize = 1;
-const OUT_468: usize = 1;
-fn aiur_fn_468(
-  inp: [G; IN_468],
+const INPUT_SIZE_454: usize = 1;
+const IN_454: usize = 1;
+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_468], ExecError> {
+) -> Result<[G; OUT_454], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[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 __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_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_0, __v_2]; 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 __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_1, __v_0, __v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(2);
     let __v_5: G = G::from_u64(1);
@@ -41602,21 +40540,21 @@ fn aiur_fn_468(
     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_468] = [__v_9];
-    record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_454] = [__v_9];
+    record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_469: usize = 3;
-const IN_469: usize = 3;
-const OUT_469: usize = 1;
-fn aiur_fn_469(
-  inp: [G; IN_469],
+const INPUT_SIZE_455: usize = 3;
+const IN_455: usize = 3;
+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_469], 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];
@@ -41627,21 +40565,21 @@ fn aiur_fn_469(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_4]; 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 __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 __ret: [G; OUT_469] = [__v_2];
-            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_455] = [__v_2];
+            record.function_queries[455].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_469] = { let __args: [G; IN_469] = [__v_0, __v_5, __v_8]; 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 __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_5, __v_8]; 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_9: G = __r_arr[0];
-            let __ret: [G; OUT_469] = [__v_9];
-            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_455] = [__v_9];
+            record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -41656,15 +40594,15 @@ fn aiur_fn_469(
   })
 }
 
-const INPUT_SIZE_470: usize = 5;
-const IN_470: usize = 5;
-const OUT_470: usize = 1;
-fn aiur_fn_470(
-  inp: [G; IN_470],
+const INPUT_SIZE_456: usize = 5;
+const IN_456: usize = 5;
+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_470], 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];
@@ -41675,38 +40613,38 @@ fn aiur_fn_470(
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_470] = [__v_6];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_456] = [__v_6];
+        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1]; 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 __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_6, __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 __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6, __v_7]; 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 __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_2, __v_8]; 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 __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_9, __v_3, __v_4]; 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 __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_9, __v_3, __v_4]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_470] = [__v_10];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_456] = [__v_10];
+        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_471: usize = 5;
-const IN_471: usize = 5;
-const OUT_471: usize = 1;
-fn aiur_fn_471(
-  inp: [G; IN_471],
+const INPUT_SIZE_457: usize = 5;
+const IN_457: usize = 5;
+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_471], 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];
@@ -41716,17 +40654,17 @@ fn aiur_fn_471(
     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() {
       1u64 => {
-        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_471] = [__v_6];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_457] = [__v_6];
+        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_471] = [__v_6];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_457] = [__v_6];
+        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41736,152 +40674,152 @@ fn aiur_fn_471(
   })
 }
 
-const INPUT_SIZE_472: usize = 5;
-const IN_472: usize = 5;
-const OUT_472: usize = 1;
-fn aiur_fn_472(
-  inp: [G; IN_472],
+const INPUT_SIZE_458: usize = 5;
+const IN_458: usize = 5;
+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_472], 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 = inp[4];
-    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_472] = [__v_6];
-        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_458] = [__v_6];
+        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_472] = [__v_7];
-            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_458] = [__v_7];
+            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_2, __v_3, __v_4]; 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_408] = { let __args: [G; IN_408] = [__v_0, __v_2, __v_3, __v_4]; 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_1, __v_2, __v_3, __v_4]; 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_408] = { let __args: [G; IN_408] = [__v_1, __v_2, __v_3, __v_4]; 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];
             let __v_9: G = (__v_7 - __v_8);
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_472] = [__v_10];
-                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_458] = [__v_10];
+                record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_7, __v_8, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_8, __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_10: G = __r_arr[0];
                 match __v_10.as_canonical_u64() {
                   1u64 => {
                     let __v_11: G = G::from_u64(1);
-                    let __ret: [G; OUT_472] = [__v_11];
-                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_458] = [__v_11];
+                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7, __v_8, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_7, __v_8, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
                     match __v_11.as_canonical_u64() {
                       1u64 => {
                         let __v_12: G = G::from_u64(1);
-                        let __ret: [G; OUT_472] = [__v_12];
-                        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_458] = [__v_12];
+                        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-                        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_1, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_1, __v_2, __v_3, __v_4]; 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_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_472] = [__v_15];
-                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_458] = [__v_15];
+                            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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_15: G = __r_arr[0];
                             match __v_15.as_canonical_u64() {
                               1u64 => {
                                 let __v_16: G = G::from_u64(1);
-                                let __ret: [G; OUT_472] = [__v_16];
-                                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_458] = [__v_16];
+                                record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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_16: G = __r_arr[0];
                                 match __v_16.as_canonical_u64() {
                                   1u64 => {
                                     let __v_17: G = G::from_u64(1);
-                                    let __ret: [G; OUT_472] = [__v_17];
-                                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_458] = [__v_17];
+                                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_12, __v_13, __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 __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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_17: G = __r_arr[0];
                                     match __v_17.as_canonical_u64() {
                                       1u64 => {
                                         let __v_18: G = G::from_u64(1);
-                                        let __ret: [G; OUT_472] = [__v_18];
-                                        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_458] = [__v_18];
+                                        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       0u64 => {
-                                        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_13, __v_12, __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 __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_13, __v_12, __v_2, __v_3, __v_4]; 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_18: G = __r_arr[0];
                                         match __v_18.as_canonical_u64() {
                                           1u64 => {
                                             let __v_19: G = G::from_u64(1);
-                                            let __ret: [G; OUT_472] = [__v_19];
-                                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_458] = [__v_19];
+                                            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           0u64 => {
-                                            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_12, __v_13, __v_2, __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 __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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_19: G = __r_arr[0];
                                             let __v_20: G = __r_arr[1];
                                             match __v_19.as_canonical_u64() {
                                               1u64 => {
-                                                let __ret: [G; OUT_472] = [__v_20];
-                                                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_458] = [__v_20];
+                                                record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               0u64 => {
                                                 let __v_21: G = G::from_u64(16);
-                                                let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_12, __v_13, __v_21, __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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; 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_22: G = __r_arr[0];
                                                 let __v_23: G = __r_arr[1];
                                                 match __v_22.as_canonical_u64() {
                                                   1u64 => {
-                                                    let __ret: [G; OUT_472] = [__v_23];
-                                                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_458] = [__v_23];
+                                                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   0u64 => {
-                                                    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 __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_12, __v_13, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0];
-                                                    let __ret: [G; OUT_472] = [__v_24];
-                                                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_458] = [__v_24];
+                                                    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -41940,15 +40878,15 @@ fn aiur_fn_472(
   })
 }
 
-const INPUT_SIZE_473: usize = 5;
-const IN_473: usize = 5;
-const OUT_473: usize = 1;
-fn aiur_fn_473(
-  inp: [G; IN_473],
+const INPUT_SIZE_459: usize = 5;
+const IN_459: usize = 5;
+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_473], 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];
@@ -41969,16 +40907,16 @@ fn aiur_fn_473(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_10]; 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 __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_473] = [__v_13];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_459] = [__v_13];
+            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_473] = [__v_13];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_459] = [__v_13];
+            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41991,22 +40929,22 @@ fn aiur_fn_473(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_470] = { let __args: [G; IN_470] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __ret: [G; OUT_473] = [__v_16];
-                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_459] = [__v_16];
+                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_473] = [__v_14];
-                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_459] = [__v_14];
+                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42016,8 +40954,8 @@ fn aiur_fn_473(
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_473] = [__v_13];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_459] = [__v_13];
+            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42030,22 +40968,22 @@ fn aiur_fn_473(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_470] = { let __args: [G; IN_470] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __ret: [G; OUT_473] = [__v_16];
-                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_459] = [__v_16];
+                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_473] = [__v_14];
-                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_459] = [__v_14];
+                record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42055,55 +40993,55 @@ fn aiur_fn_473(
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_473] = [__v_13];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_459] = [__v_13];
+            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_473] = [__v_9];
-        record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_9];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_474: usize = 5;
-const IN_474: usize = 5;
-const OUT_474: usize = 1;
-fn aiur_fn_474(
-  inp: [G; IN_474],
+const INPUT_SIZE_460: usize = 5;
+const IN_460: usize = 5;
+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_474], ExecError> {
+) -> Result<[G; OUT_460], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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_456] = { let __args: [G; IN_456] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_5, __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 __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_5, __v_2, __v_3, __v_4]; 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_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_474] = [__v_7];
-        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_7];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1, __v_2, __v_3, __v_4]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_5, __v_7, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_7, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_474] = [__v_8];
-        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_8];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42113,23 +41051,23 @@ fn aiur_fn_474(
   })
 }
 
-const INPUT_SIZE_475: usize = 4;
-const IN_475: usize = 4;
-const OUT_475: usize = 1;
-fn aiur_fn_475(
-  inp: [G; IN_475],
+const INPUT_SIZE_461: usize = 4;
+const IN_461: usize = 4;
+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_475], 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2, __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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_1, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_4, __v_1, __v_2, __v_3]; 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_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];
@@ -42145,63 +41083,63 @@ fn aiur_fn_475(
         match __v_10.as_canonical_u64() {
           0u64 => {
             let __v_13: G = G::from_u64(1);
-            let __ret: [G; OUT_475] = [__v_13];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_461] = [__v_13];
+            record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_475] = [__v_13];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_461] = [__v_13];
+            record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_475] = [__v_10];
-        record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_461] = [__v_10];
+        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_476: usize = 5;
-const IN_476: usize = 5;
-const OUT_476: usize = 1;
-fn aiur_fn_476(
-  inp: [G; IN_476],
+const INPUT_SIZE_462: usize = 5;
+const IN_462: usize = 5;
+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_476], 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_5, __v_2, __v_3, __v_4]; 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];
-    let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_6, __v_3]; 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 __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_6, __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_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_476] = [__v_8];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_462] = [__v_8];
+        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_5, __v_8, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_8, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_476] = [__v_9];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_462] = [__v_9];
+        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42211,19 +41149,19 @@ fn aiur_fn_476(
   })
 }
 
-const INPUT_SIZE_477: usize = 2;
-const IN_477: usize = 2;
-const OUT_477: usize = 1;
-fn aiur_fn_477(
-  inp: [G; IN_477],
+const INPUT_SIZE_463: usize = 2;
+const IN_463: usize = 2;
+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_477], 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 __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 __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 };
@@ -42233,7 +41171,7 @@ fn aiur_fn_477(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_5]; 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 __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];
@@ -42249,14 +41187,14 @@ fn aiur_fn_477(
         let __v_19: G = __loaded[10];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_14]; 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 __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_781] = { let __args: [G; IN_781] = [__v_14, __v_21]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_14, __v_21]; 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 __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_22]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_22]; 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 __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];
@@ -42275,81 +41213,81 @@ fn aiur_fn_477(
                     match __v_30.as_canonical_u64() {
                       0u64 => {
                         let __v_35: G = G::from_u64(1);
-                        let __ret: [G; OUT_477] = [__v_35];
-                        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_463] = [__v_35];
+                        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_35: G = G::from_u64(0);
-                        let __ret: [G; OUT_477] = [__v_35];
-                        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_463] = [__v_35];
+                        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_35: G = G::from_u64(0);
-                    let __ret: [G; OUT_477] = [__v_35];
-                    record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_463] = [__v_35];
+                    record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_21: G = G::from_u64(0);
-                let __ret: [G; OUT_477] = [__v_21];
-                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_463] = [__v_21];
+                record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_477] = [__v_20];
-            record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_463] = [__v_20];
+            record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_477] = [__v_8];
-        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_463] = [__v_8];
+        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_478: usize = 5;
-const IN_478: usize = 5;
-const OUT_478: usize = 1;
-fn aiur_fn_478(
-  inp: [G; IN_478],
+const INPUT_SIZE_464: usize = 5;
+const IN_464: usize = 5;
+const OUT_464: usize = 1;
+fn aiur_fn_464(
+  inp: [G; IN_464],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_478], 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 __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __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];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_478] = [__v_6];
-        record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_464] = [__v_6];
+        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_0, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_1, __v_0, __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_6: G = __r_arr[0];
-        let __ret: [G; OUT_478] = [__v_6];
-        record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_464] = [__v_6];
+        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42359,15 +41297,15 @@ fn aiur_fn_478(
   })
 }
 
-const INPUT_SIZE_479: usize = 5;
-const IN_479: usize = 5;
-const OUT_479: usize = 1;
-fn aiur_fn_479(
-  inp: [G; IN_479],
+const INPUT_SIZE_465: usize = 5;
+const IN_465: usize = 5;
+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_479], 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];
@@ -42383,21 +41321,21 @@ fn aiur_fn_479(
       7u64 => {
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_7, __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 __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_479] = [__v_11];
-                record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_465] = [__v_11];
+                record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_479] = [__v_11];
-                record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_465] = [__v_11];
+                record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42407,31 +41345,31 @@ fn aiur_fn_479(
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_479] = [__v_9];
-            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_465] = [__v_9];
+            record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_479] = [__v_9];
-        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_465] = [__v_9];
+        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_480: usize = 2;
-const IN_480: usize = 2;
-const OUT_480: usize = 1;
-fn aiur_fn_480(
-  inp: [G; IN_480],
+const INPUT_SIZE_466: usize = 2;
+const IN_466: usize = 2;
+const OUT_466: usize = 1;
+fn aiur_fn_466(
+  inp: [G; IN_466],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_480], ExecError> {
+) -> 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];
@@ -42444,50 +41382,50 @@ fn aiur_fn_480(
       7u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__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 __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_6: G = __r_arr[0];
-            let __ret: [G; OUT_480] = [__v_6];
-            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_466] = [__v_6];
+            record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_480] = [__v_6];
-            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_466] = [__v_6];
+            record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_3]; 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 __v_6: G = __r_arr[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 __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_130] = { let __args: [G; IN_130] = [__v_6, __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 __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_480] = [__v_8];
-        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_466] = [__v_8];
+        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_480] = [__v_6];
-        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_466] = [__v_6];
+        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_481: usize = 2;
-const IN_481: usize = 2;
-const OUT_481: usize = 3;
-fn aiur_fn_481(
-  inp: [G; IN_481],
+const INPUT_SIZE_467: usize = 2;
+const IN_467: usize = 2;
+const OUT_467: usize = 3;
+fn aiur_fn_467(
+  inp: [G; IN_467],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_481], 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];
@@ -42504,10 +41442,10 @@ fn aiur_fn_481(
             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_344] = { let __args: [G; IN_344] = [__v_9]; 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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 __ret: [G; OUT_481] = [__v_6, __v_10, __v_4];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_467] = [__v_6, __v_10, __v_4];
+            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -42515,8 +41453,8 @@ fn aiur_fn_481(
             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_481] = [__v_6, __v_0, __v_9];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_467] = [__v_6, __v_0, __v_9];
+            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42529,23 +41467,23 @@ fn aiur_fn_481(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_7]; 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 __v_10: 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 __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_130] = { let __args: [G; IN_130] = [__v_10, __v_11]; 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 __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() {
               1u64 => {
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_4, __v_1]; 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_467] = { let __args: [G; IN_467] = [__v_4, __v_1]; 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_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_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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_15]; 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_17: G = __r_arr[0];
-                let __ret: [G; OUT_481] = [__v_16, __v_14, __v_17];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_467] = [__v_16, __v_14, __v_17];
+                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -42553,8 +41491,8 @@ fn aiur_fn_481(
                 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_481] = [__v_13, __v_0, __v_16];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_467] = [__v_13, __v_0, __v_16];
+                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42570,11 +41508,11 @@ fn aiur_fn_481(
             let __v_13: G = __loaded[3];
             match __v_10.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_11]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_11]; 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 __v_14: G = __r_arr[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 __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_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_15]; 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 __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() {
                   1u64 => {
@@ -42587,23 +41525,23 @@ fn aiur_fn_481(
                       7u64 => {
                         match __v_18.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_1]; 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_467] = { let __args: [G; IN_467] = [__v_8, __v_1]; 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_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() {
                               1u64 => {
                                 let __v_24: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_23, __v_19]; 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 __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_23, __v_19]; 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_25: G = __r_arr[0];
-                                let __ret: [G; OUT_481] = [__v_24, __v_22, __v_25];
-                                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_467] = [__v_24, __v_22, __v_25];
+                                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_24: G = G::from_u64(1);
-                                let __ret: [G; OUT_481] = [__v_24, __v_8, __v_19];
-                                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_467] = [__v_24, __v_8, __v_19];
+                                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -42616,8 +41554,8 @@ fn aiur_fn_481(
                             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_481] = [__v_21, __v_0, __v_24];
-                            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_467] = [__v_21, __v_0, __v_24];
+                            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -42627,8 +41565,8 @@ fn aiur_fn_481(
                         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_481] = [__v_21, __v_0, __v_24];
-                        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_467] = [__v_21, __v_0, __v_24];
+                        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -42638,8 +41576,8 @@ fn aiur_fn_481(
                     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_481] = [__v_17, __v_0, __v_20];
-                    record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_467] = [__v_17, __v_0, __v_20];
+                    record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -42652,8 +41590,8 @@ fn aiur_fn_481(
                 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_481] = [__v_14, __v_0, __v_17];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_467] = [__v_14, __v_0, __v_17];
+                record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -42663,8 +41601,8 @@ fn aiur_fn_481(
             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_481] = [__v_10, __v_0, __v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_467] = [__v_10, __v_0, __v_13];
+            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42674,48 +41612,48 @@ fn aiur_fn_481(
         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_481] = [__v_6, __v_0, __v_9];
-        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_467] = [__v_6, __v_0, __v_9];
+        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_482: usize = 5;
-const IN_482: usize = 5;
-const OUT_482: usize = 2;
-fn aiur_fn_482(
-  inp: [G; IN_482],
+const INPUT_SIZE_468: usize = 5;
+const IN_468: usize = 5;
+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_482], 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 __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_0, __v_4]; 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_1, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = (__v_5 * __v_6);
     match __v_7.as_canonical_u64() {
       1u64 => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_482] = [__v_8, __v_9];
-        record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_468] = [__v_8, __v_9];
+        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __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_467] = { let __args: [G; IN_467] = [__v_0, __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 __v_9: G = __r_arr[1];
         let __v_10: G = __r_arr[2];
-        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_1, __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_467] = { let __args: [G; IN_467] = [__v_1, __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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -42724,27 +41662,27 @@ fn aiur_fn_482(
           0u64 => {
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
-            let __ret: [G; OUT_482] = [__v_15, __v_16];
-            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_468] = [__v_15, __v_16];
+            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_10, __v_13]; 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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_10, __v_13]; 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_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(0);
-                let __ret: [G; OUT_482] = [__v_16, __v_17];
-                record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_468] = [__v_16, __v_17];
+                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_9, __v_12, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_9, __v_12, __v_2, __v_3, __v_4]; 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_17: G = __r_arr[0];
-                let __ret: [G; OUT_482] = [__v_16, __v_17];
-                record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_468] = [__v_16, __v_17];
+                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42761,22 +41699,22 @@ fn aiur_fn_482(
   })
 }
 
-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_469: usize = 5;
+const IN_469: usize = 5;
+const OUT_469: usize = 1;
+fn aiur_fn_469(
+  inp: [G; IN_469],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_483], 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 __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; 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 __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 };
@@ -42786,7 +41724,7 @@ fn aiur_fn_483(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_8]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_8]; 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 __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];
@@ -42802,13 +41740,13 @@ fn aiur_fn_483(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; 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 __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_781] = { let __args: [G; IN_781] = [__v_3, __v_15]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_15]; 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 __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];
@@ -42825,7 +41763,7 @@ fn aiur_fn_483(
                 match __v_27.as_canonical_u64() {
                   5u64 => {
                     let __v_38: G = G::from_bool((__v_31 == G::ZERO));
-                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_32]; 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 __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);
@@ -42834,26 +41772,26 @@ fn aiur_fn_483(
                     match __v_43.as_canonical_u64() {
                       0u64 => {
                         let __v_44: G = G::from_u64(0);
-                        let __ret: [G; OUT_483] = [__v_44];
-                        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_469] = [__v_44];
+                        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
-                        let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_15, __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 __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_15, __v_3]; 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_44: G = __r_arr[0];
                         match __v_44.as_canonical_u64() {
                           1u64 => {
                             let __v_45: G = G::from_u64(0);
-                            let __ret: [G; OUT_483] = [__v_45];
-                            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_469] = [__v_45];
+                            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
                             let __v_45: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__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[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 __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__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[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_46: G = __r_arr[0];
-                            let __ret: [G; OUT_483] = [__v_46];
-                            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_469] = [__v_46];
+                            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -42868,47 +41806,47 @@ fn aiur_fn_483(
                   },
                   _ => {
                     let __v_38: G = G::from_u64(0);
-                    let __ret: [G; OUT_483] = [__v_38];
-                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_469] = [__v_38];
+                    record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_26: G = G::from_u64(0);
-                let __ret: [G; OUT_483] = [__v_26];
-                record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_469] = [__v_26];
+                record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_483] = [__v_23];
-            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_469] = [__v_23];
+            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_483] = [__v_11];
-        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_469] = [__v_11];
+        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_484: usize = 9;
-const IN_484: usize = 9;
-const OUT_484: usize = 1;
-fn aiur_fn_484(
-  inp: [G; IN_484],
+const INPUT_SIZE_470: usize = 9;
+const IN_470: usize = 9;
+const OUT_470: usize = 1;
+fn aiur_fn_470(
+  inp: [G; IN_470],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_484], 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];
@@ -42923,32 +41861,32 @@ fn aiur_fn_484(
     match __v_9.as_canonical_u64() {
       0u64 => {
         let __v_10: G = G::from_u64(1);
-        let __ret: [G; OUT_484] = [__v_10];
-        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_470] = [__v_10];
+        record.function_queries[470].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_781] = { let __args: [G; IN_781] = [__v_4, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_12]; 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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_11, __v_13, __v_6, __v_7, __v_8]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_11, __v_13, __v_6, __v_7, __v_8]; 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_14: G = __r_arr[0];
         match __v_14.as_canonical_u64() {
           0u64 => {
             let __v_15: G = G::from_u64(0);
-            let __ret: [G; OUT_484] = [__v_15];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_470] = [__v_15];
+            record.function_queries[470].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_484] = { let __args: [G; IN_484] = [__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[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 __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__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[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_17: G = __r_arr[0];
-            let __ret: [G; OUT_484] = [__v_17];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_470] = [__v_17];
+            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -42960,15 +41898,15 @@ fn aiur_fn_484(
   })
 }
 
-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_471: usize = 5;
+const IN_471: usize = 5;
+const OUT_471: usize = 1;
+fn aiur_fn_471(
+  inp: [G; IN_471],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_485], 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];
@@ -42989,23 +41927,23 @@ fn aiur_fn_485(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_10]; 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 __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_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43022,29 +41960,29 @@ fn aiur_fn_485(
             match __v_13.as_canonical_u64() {
               0u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43060,31 +41998,31 @@ fn aiur_fn_485(
             let __v_13: G = (__v_6 - __v_10);
             match __v_13.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_7, __v_11]; 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 __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_7, __v_11]; 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_14: G = __r_arr[0];
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43097,20 +42035,20 @@ fn aiur_fn_485(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_11, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_11, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0];
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43119,16 +42057,16 @@ fn aiur_fn_485(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43141,22 +42079,22 @@ fn aiur_fn_485(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_470] = { let __args: [G; IN_470] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __ret: [G; OUT_485] = [__v_16];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_16];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43165,10 +42103,10 @@ fn aiur_fn_485(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_6, __v_7, __v_1, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_7, __v_1, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43181,22 +42119,22 @@ fn aiur_fn_485(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_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_470] = { let __args: [G; IN_470] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_11, __v_15, __v_3, __v_4]; 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 __ret: [G; OUT_485] = [__v_16];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_16];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43205,16 +42143,16 @@ fn aiur_fn_485(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43227,26 +42165,26 @@ fn aiur_fn_485(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_6, __v_10, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_11, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_11, __v_2, __v_3, __v_4]; 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_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_470] = { let __args: [G; IN_470] = [__v_8, __v_12, __v_16, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_8, __v_12, __v_16, __v_3, __v_4]; 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_17: G = __r_arr[0];
-                    let __ret: [G; OUT_485] = [__v_17];
-                    record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_471] = [__v_17];
+                    record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_15: G = G::from_u64(0);
-                    let __ret: [G; OUT_485] = [__v_15];
-                    record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_471] = [__v_15];
+                    record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -43256,8 +42194,8 @@ fn aiur_fn_485(
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_485] = [__v_14];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_14];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43266,16 +42204,16 @@ fn aiur_fn_485(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43288,23 +42226,23 @@ fn aiur_fn_485(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6, __v_7, __v_10, __v_11]; 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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_10, __v_11]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43324,16 +42262,16 @@ fn aiur_fn_485(
             let __v_17: G = (__v_14 * __v_16);
             match __v_17.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_8, __v_12, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_8, __v_12, __v_2, __v_3, __v_4]; 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_18: G = __r_arr[0];
-                let __ret: [G; OUT_485] = [__v_18];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_18];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_18: G = G::from_u64(0);
-                let __ret: [G; OUT_485] = [__v_18];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_471] = [__v_18];
+                record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43342,16 +42280,16 @@ fn aiur_fn_485(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_10, __v_11, __v_0, __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 __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_13];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_471] = [__v_13];
+            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43363,15 +42301,15 @@ fn aiur_fn_485(
   })
 }
 
-const INPUT_SIZE_486: usize = 6;
-const IN_486: usize = 6;
-const OUT_486: usize = 1;
-fn aiur_fn_486(
-  inp: [G; IN_486],
+const INPUT_SIZE_472: usize = 6;
+const IN_472: usize = 6;
+const OUT_472: usize = 1;
+fn aiur_fn_472(
+  inp: [G; IN_472],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_486], 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];
@@ -43381,7 +42319,7 @@ fn aiur_fn_486(
     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_400] = { let __args: [G; IN_400] = [__v_2, __v_6, __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 __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2, __v_6, __v_7]; 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_8: G = __r_arr[0];
     let __v_9: G = G::from_u64(0);
     let __v_10: G = G::from_u64(0);
@@ -43392,23 +42330,23 @@ fn aiur_fn_486(
     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_470] = { let __args: [G; IN_470] = [__v_1, __v_15, __v_17, __v_4, __v_5]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1, __v_15, __v_17, __v_4, __v_5]; 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_18: G = __r_arr[0];
-    let __ret: [G; OUT_486] = [__v_18];
-    record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_472] = [__v_18];
+    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_487: usize = 2;
-const IN_487: usize = 2;
-const OUT_487: usize = 1;
-fn aiur_fn_487(
-  inp: [G; IN_487],
+const INPUT_SIZE_473: usize = 2;
+const IN_473: usize = 2;
+const OUT_473: usize = 1;
+fn aiur_fn_473(
+  inp: [G; IN_473],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_487], 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];
@@ -43425,14 +42363,14 @@ fn aiur_fn_487(
         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));
+            let __ret: [G; OUT_473] = [__v_8];
+            record.function_queries[473].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));
+            let __ret: [G; OUT_473] = [__v_8];
+            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43445,25 +42383,25 @@ fn aiur_fn_487(
         match __v_5.as_canonical_u64() {
           1u64 => {
             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));
+            let __ret: [G; OUT_473] = [__v_8];
+            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_6]; 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 __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() {
               1u64 => {
-                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 __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_487] = [__v_9];
-                record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_473] = [__v_9];
+                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_487] = [__v_9];
-                record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_473] = [__v_9];
+                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43483,25 +42421,25 @@ fn aiur_fn_487(
   })
 }
 
-const INPUT_SIZE_488: usize = 5;
-const IN_488: usize = 5;
-const OUT_488: usize = 1;
-fn aiur_fn_488(
-  inp: [G; IN_488],
+const INPUT_SIZE_474: usize = 5;
+const IN_474: usize = 5;
+const OUT_474: usize = 1;
+fn aiur_fn_474(
+  inp: [G; IN_474],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_488], ExecError> {
+) -> Result<[G; OUT_474], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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_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 __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_202] = { let __args: [G; IN_202] = [__v_1]; 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 __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 };
@@ -43521,33 +42459,33 @@ fn aiur_fn_488(
             let __v_17: G = (__v_10 - __v_14);
             match __v_17.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_11, __v_15]; 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 __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_11, __v_15]; 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_18: G = __r_arr[0];
                 match __v_18.as_canonical_u64() {
                   0u64 => {
                     let __v_19: G = G::from_u64(0);
-                    let __ret: [G; OUT_488] = [__v_19];
-                    record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_474] = [__v_19];
+                    record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; 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 __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_200] = { let __args: [G; IN_200] = [__v_8]; 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 __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() {
                       0u64 => {
-                        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_6, __v_8, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_6, __v_8, __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_22: G = __r_arr[0];
-                        let __ret: [G; OUT_488] = [__v_22];
-                        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_474] = [__v_22];
+                        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_488] = [__v_22];
-                        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_474] = [__v_22];
+                        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -43559,39 +42497,39 @@ fn aiur_fn_488(
               },
               _ => {
                 let __v_18: G = G::from_u64(0);
-                let __ret: [G; OUT_488] = [__v_18];
-                record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_474] = [__v_18];
+                record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_17: G = G::from_u64(0);
-            let __ret: [G; OUT_488] = [__v_17];
-            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_474] = [__v_17];
+            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_488] = [__v_13];
-        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_474] = [__v_13];
+        record.function_queries[474].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_475: usize = 5;
+const IN_475: usize = 5;
+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_489], 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];
@@ -43611,14 +42549,14 @@ fn aiur_fn_489(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(1);
-            let __ret: [G; OUT_489] = [__v_11];
-            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_475] = [__v_11];
+            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_489] = [__v_11];
-            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_475] = [__v_11];
+            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43631,25 +42569,25 @@ fn aiur_fn_489(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_489] = [__v_11];
-            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_475] = [__v_11];
+            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_6, __v_9, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_6, __v_9, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_489] = [__v_12];
-                record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_475] = [__v_12];
+                record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_7, __v_10, __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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_10, __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_489] = [__v_12];
-                record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_475] = [__v_12];
+                record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43669,19 +42607,19 @@ fn aiur_fn_489(
   })
 }
 
-const INPUT_SIZE_490: usize = 2;
-const IN_490: usize = 2;
-const OUT_490: usize = 1;
-fn aiur_fn_490(
-  inp: [G; IN_490],
+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_490], 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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_0]; 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 __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];
@@ -43698,39 +42636,39 @@ fn aiur_fn_490(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_490] = [__v_14];
-        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_476] = [__v_14];
+        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_490] = [__v_14];
-        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_476] = [__v_14];
+        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_490] = [__v_14];
-        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_476] = [__v_14];
+        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_477: usize = 2;
+const IN_477: usize = 2;
+const OUT_477: usize = 1;
+fn aiur_fn_477(
+  inp: [G; IN_477],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_491], 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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_0]; 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 __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];
@@ -43746,33 +42684,33 @@ fn aiur_fn_491(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_491] = [__v_8];
-        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_477] = [__v_8];
+        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_491] = [__v_14];
-        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_477] = [__v_14];
+        record.function_queries[477].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 = 2;
-fn aiur_fn_492(
-  inp: [G; IN_492],
+const INPUT_SIZE_478: usize = 2;
+const IN_478: usize = 2;
+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_492], 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 __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 __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 };
@@ -43782,7 +42720,7 @@ fn aiur_fn_492(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_5]; 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 __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];
@@ -43798,56 +42736,56 @@ fn aiur_fn_492(
         let __v_19: G = __loaded[10];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_12, __v_6]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_12, __v_6]; 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_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_20, __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_22: G = __r_arr[0];
-            let __ret: [G; OUT_492] = [__v_21, __v_22];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_478] = [__v_21, __v_22];
+            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_12, __v_6]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_12, __v_6]; 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_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_20, __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_22: G = __r_arr[0];
-            let __ret: [G; OUT_492] = [__v_21, __v_22];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_478] = [__v_21, __v_22];
+            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_492] = [__v_20, __v_0];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_478] = [__v_20, __v_0];
+            record.function_queries[478].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, __v_0];
-        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_478] = [__v_8, __v_0];
+        record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_493: usize = 2;
-const IN_493: usize = 2;
-const OUT_493: usize = 2;
-fn aiur_fn_493(
-  inp: [G; IN_493],
+const INPUT_SIZE_479: usize = 2;
+const IN_479: usize = 2;
+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_493], 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 __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 __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 };
@@ -43857,7 +42795,7 @@ fn aiur_fn_493(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       8u64 => {
-        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_7, __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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_1]; 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];
         match __v_8.as_canonical_u64() {
@@ -43865,16 +42803,16 @@ fn aiur_fn_493(
             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_414] = { let __args: [G; IN_414] = [__v_11, __v_3]; 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_400] = { let __args: [G; IN_400] = [__v_11, __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_13: G = __r_arr[0];
-            let __ret: [G; OUT_493] = [__v_12, __v_13];
-            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_479] = [__v_12, __v_13];
+            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_493] = [__v_10, __v_0];
-            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_479] = [__v_10, __v_0];
+            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -43884,23 +42822,23 @@ fn aiur_fn_493(
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_493] = [__v_8, __v_0];
-        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_479] = [__v_8, __v_0];
+        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_494: usize = 6;
-const IN_494: usize = 6;
-const OUT_494: usize = 2;
-fn aiur_fn_494(
-  inp: [G; IN_494],
+const INPUT_SIZE_480: usize = 6;
+const IN_480: usize = 6;
+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_494], 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];
@@ -43912,8 +42850,8 @@ fn aiur_fn_494(
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_494] = [__v_6, __v_7];
-        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_480] = [__v_6, __v_7];
+        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -43922,15 +42860,15 @@ fn aiur_fn_494(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_494] = [__v_7, __v_8];
-            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_480] = [__v_7, __v_8];
+            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            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 __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_202] = { let __args: [G; IN_202] = [__v_1]; 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 __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 };
@@ -43947,32 +42885,32 @@ fn aiur_fn_494(
                 let __v_18: G = __loaded[3];
                 match __v_15.as_canonical_u64() {
                   2u64 => {
-                    let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__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[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 __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__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[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_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_494] = [__v_20, __v_21];
-                        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_480] = [__v_20, __v_21];
+                        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__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[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 __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__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[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_20: G = __r_arr[0];
                         let __v_21: G = __r_arr[1];
-                        let __ret: [G; OUT_494] = [__v_20, __v_21];
-                        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_480] = [__v_20, __v_21];
+                        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_494] = [__v_19, __v_20];
-                    record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_480] = [__v_19, __v_20];
+                    record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -43985,18 +42923,18 @@ fn aiur_fn_494(
                 let __v_18: G = __loaded[3];
                 match __v_15.as_canonical_u64() {
                   2u64 => {
-                    let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __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_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_494] = [__v_19, __v_20];
-                    record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_480] = [__v_19, __v_20];
+                    record.function_queries[480].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_494] = [__v_19, __v_20];
-                    record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_480] = [__v_19, __v_20];
+                    record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -44009,15 +42947,15 @@ fn aiur_fn_494(
   })
 }
 
-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_481: usize = 9;
+const IN_481: usize = 9;
+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_495], ExecError> {
+) -> 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];
@@ -44031,33 +42969,33 @@ fn aiur_fn_495(
     let __v_9: G = (__v_0 - __v_3);
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __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 __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_4]; 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_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           0u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_495] = [__v_11];
-            record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_481] = [__v_11];
+            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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_200] = { let __args: [G; IN_200] = [__v_5]; 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 __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() {
               0u64 => {
-                let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_2, __v_5, __v_6, __v_7, __v_8]; 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 __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_5, __v_6, __v_7, __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_14: G = __r_arr[0];
-                let __ret: [G; OUT_495] = [__v_14];
-                record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_481] = [__v_14];
+                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_495] = [__v_14];
-                record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_481] = [__v_14];
+                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -44069,23 +43007,23 @@ fn aiur_fn_495(
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_495] = [__v_10];
-        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_481] = [__v_10];
+        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_496: usize = 8;
-const IN_496: usize = 8;
-const OUT_496: usize = 2;
-fn aiur_fn_496(
-  inp: [G; IN_496],
+const INPUT_SIZE_482: usize = 8;
+const IN_482: usize = 8;
+const OUT_482: usize = 2;
+fn aiur_fn_482(
+  inp: [G; IN_482],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_496], ExecError> {
+) -> 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];
@@ -44095,9 +43033,9 @@ fn aiur_fn_496(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_6]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_6]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1, __v_6]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_6]; 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_9: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       0u64 => {
@@ -44105,23 +43043,23 @@ fn aiur_fn_496(
           0u64 => {
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_10, __v_11];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_10, __v_11];
+            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_3, __v_4, __v_5, __v_6, __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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_496] = [__v_10, __v_11];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_10, __v_11];
+            record.function_queries[482].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_496] = [__v_10, __v_11];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_10, __v_11];
+            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44129,45 +43067,45 @@ fn aiur_fn_496(
       1u64 => {
         match __v_9.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_496] = [__v_10, __v_11];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_10, __v_11];
+            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_6]; 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 __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_6]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_6]; 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 __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __v_6]; 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_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() {
               1u64 => {
-                let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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));
+                let __ret: [G; OUT_482] = [__v_13, __v_14];
+                record.function_queries[482].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_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_500] = { let __args: [G; IN_500] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_3, __v_4, __v_5, __v_6, __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_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_496] = [__v_14, __v_15];
-                    record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_482] = [__v_14, __v_15];
+                    record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_3, __v_4, __v_5, __v_6, __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_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_496] = [__v_14, __v_15];
-                    record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_482] = [__v_14, __v_15];
+                    record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -44183,8 +43121,8 @@ fn aiur_fn_496(
           _ => {
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_10, __v_11];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_10, __v_11];
+            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44192,23 +43130,23 @@ fn aiur_fn_496(
       _ => {
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_496] = [__v_10, __v_11];
-        record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_482] = [__v_10, __v_11];
+        record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_497: usize = 7;
-const IN_497: usize = 7;
-const OUT_497: usize = 2;
-fn aiur_fn_497(
-  inp: [G; IN_497],
+const INPUT_SIZE_483: usize = 7;
+const IN_483: usize = 7;
+const OUT_483: usize = 2;
+fn aiur_fn_483(
+  inp: [G; IN_483],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_497], 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];
@@ -44217,39 +43155,39 @@ fn aiur_fn_497(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __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_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_497] = [__v_8, __v_9];
-        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_483] = [__v_8, __v_9];
+        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_5]; 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 __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_5]; 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 __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_4, __v_5, __v_6]; 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_414] = { let __args: [G; IN_414] = [__v_9, __v_4, __v_5, __v_6]; 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_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_494] = { let __args: [G; IN_494] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; 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_497] = [__v_13, __v_14];
-            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_483] = [__v_13, __v_14];
+            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_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_497] = [__v_10, __v_11];
-            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_483] = [__v_10, __v_11];
+            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44260,23 +43198,23 @@ fn aiur_fn_497(
       _ => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_497] = [__v_8, __v_9];
-        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_483] = [__v_8, __v_9];
+        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_498: usize = 7;
-const IN_498: usize = 7;
-const OUT_498: usize = 2;
-fn aiur_fn_498(
-  inp: [G; IN_498],
+const INPUT_SIZE_484: usize = 7;
+const IN_484: usize = 7;
+const OUT_484: usize = 2;
+fn aiur_fn_484(
+  inp: [G; IN_484],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_498], 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];
@@ -44285,39 +43223,39 @@ fn aiur_fn_498(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __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_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_498] = [__v_8, __v_9];
-        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_484] = [__v_8, __v_9];
+        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_5]; 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 __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_4, __v_5, __v_6]; 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_414] = { let __args: [G; IN_414] = [__v_9, __v_4, __v_5, __v_6]; 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_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_494] = { let __args: [G; IN_494] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; 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_498] = [__v_13, __v_14];
-            record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_484] = [__v_13, __v_14];
+            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_498] = [__v_10, __v_11];
-            record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_484] = [__v_10, __v_11];
+            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44328,23 +43266,23 @@ fn aiur_fn_498(
       _ => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_498] = [__v_8, __v_9];
-        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_484] = [__v_8, __v_9];
+        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_499: usize = 6;
-const IN_499: usize = 6;
-const OUT_499: usize = 2;
-fn aiur_fn_499(
-  inp: [G; IN_499],
+const INPUT_SIZE_485: usize = 6;
+const IN_485: usize = 6;
+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_499], 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];
@@ -44352,27 +43290,27 @@ fn aiur_fn_499(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_7, __v_3, __v_4, __v_5]; 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_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_494] = { let __args: [G; IN_494] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_499] = [__v_11, __v_12];
-        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_485] = [__v_11, __v_12];
+        record.function_queries[485].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_499] = [__v_8, __v_9];
-        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_485] = [__v_8, __v_9];
+        record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44382,15 +43320,15 @@ fn aiur_fn_499(
   })
 }
 
-const INPUT_SIZE_500: usize = 6;
-const IN_500: usize = 6;
-const OUT_500: usize = 2;
-fn aiur_fn_500(
-  inp: [G; IN_500],
+const INPUT_SIZE_486: usize = 6;
+const IN_486: usize = 6;
+const OUT_486: usize = 2;
+fn aiur_fn_486(
+  inp: [G; IN_486],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_500], 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];
@@ -44398,27 +43336,27 @@ fn aiur_fn_500(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_1, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_7, __v_3, __v_4, __v_5]; 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_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_494] = { let __args: [G; IN_494] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_500] = [__v_11, __v_12];
-        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_486] = [__v_11, __v_12];
+        record.function_queries[486].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_500] = [__v_8, __v_9];
-        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_486] = [__v_8, __v_9];
+        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44428,15 +43366,15 @@ fn aiur_fn_500(
   })
 }
 
-const INPUT_SIZE_501: usize = 6;
-const IN_501: usize = 6;
-const OUT_501: usize = 2;
-fn aiur_fn_501(
-  inp: [G; IN_501],
+const INPUT_SIZE_487: usize = 6;
+const IN_487: usize = 6;
+const OUT_487: usize = 2;
+fn aiur_fn_487(
+  inp: [G; IN_487],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_501], 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];
@@ -44444,34 +43382,34 @@ fn aiur_fn_501(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        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 __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_1, __v_4]; 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];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_7, __v_3, __v_4, __v_5]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_3, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_9, __v_3, __v_4, __v_5]; 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_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_494] = { let __args: [G; IN_494] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; 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_501] = [__v_14, __v_15];
-            record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_487] = [__v_14, __v_15];
+            record.function_queries[487].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 __ret: [G; OUT_501] = [__v_10, __v_11];
-            record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_487] = [__v_10, __v_11];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44482,8 +43420,8 @@ fn aiur_fn_501(
       0u64 => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_501] = [__v_8, __v_9];
-        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_487] = [__v_8, __v_9];
+        record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44493,15 +43431,15 @@ fn aiur_fn_501(
   })
 }
 
-const INPUT_SIZE_502: usize = 7;
-const IN_502: usize = 7;
-const OUT_502: usize = 0;
-fn aiur_fn_502(
-  inp: [G; IN_502],
+const INPUT_SIZE_488: usize = 7;
+const IN_488: usize = 7;
+const OUT_488: usize = 0;
+fn aiur_fn_488(
+  inp: [G; IN_488],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_502], 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];
@@ -44511,9 +43449,9 @@ fn aiur_fn_502(
     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_505] = { let __args: [G; IN_505] = [__v_0, __v_7]; 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 __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_7]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8]; 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 __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 };
@@ -44524,14 +43462,14 @@ fn aiur_fn_502(
     match __v_11.as_canonical_u64() {
       2u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_13, __v_5, __v_15]; 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 __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_10]; 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 __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_13, __v_5, __v_15]; 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 __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_507] = { let __args: [G; IN_507] = [__v_10, __v_1, __v_3, __v_17]; 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 __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_10, __v_1]; 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_493] = { let __args: [G; IN_493] = [__v_10, __v_1, __v_3, __v_17]; 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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_4, __v_6]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_4, __v_6]; 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_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() });
@@ -44540,14 +43478,14 @@ fn aiur_fn_502(
         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_522] = { let __args: [G; IN_522] = [__v_18, __v_19]; 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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_18, __v_19]; 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_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_502] = [];
-        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_488] = [];
+        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44557,20 +43495,20 @@ fn aiur_fn_502(
   })
 }
 
-const INPUT_SIZE_503: usize = 3;
-const IN_503: usize = 3;
-const OUT_503: usize = 0;
-fn aiur_fn_503(
-  inp: [G; IN_503],
+const INPUT_SIZE_489: usize = 3;
+const IN_489: usize = 3;
+const OUT_489: usize = 0;
+fn aiur_fn_489(
+  inp: [G; IN_489],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_503], 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 = inp[2];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_0]; 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 __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];
@@ -44590,32 +43528,32 @@ fn aiur_fn_503(
         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_508] = { let __args: [G; IN_508] = [__v_6, __v_15, __v_18, __v_1, __v_2]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_6, __v_15, __v_18, __v_1, __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_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__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[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 __ret: [G; OUT_503] = [];
-        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__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[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 __ret: [G; OUT_489] = [];
+        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_503] = [];
-        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_489] = [];
+        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_504: usize = 10;
-const IN_504: usize = 10;
-const OUT_504: usize = 0;
-fn aiur_fn_504(
-  inp: [G; IN_504],
+const INPUT_SIZE_490: usize = 10;
+const IN_490: usize = 10;
+const OUT_490: usize = 0;
+fn aiur_fn_490(
+  inp: [G; IN_490],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_504], 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];
@@ -44633,12 +43571,12 @@ fn aiur_fn_504(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_504] = [];
-        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_490] = [];
+        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_8, __v_11]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_8, __v_11]; 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 __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];
@@ -44654,16 +43592,16 @@ fn aiur_fn_504(
         let __v_24: G = __loaded[10];
         match __v_14.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_2, __v_16, __v_4, __v_8, __v_9]; 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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_16, __v_19, __v_5, __v_20, __v_1, __v_3, __v_8]; 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 __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_2, __v_16, __v_4, __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 __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_16, __v_19, __v_5, __v_20, __v_1, __v_3, __v_8]; 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_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_509] = { let __args: [G; IN_509] = [__v_16, __v_19, __v_6, __v_27, __v_8, __v_9]; 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 __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_16, __v_19, __v_6, __v_27, __v_8, __v_9]; 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_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_512] = { let __args: [G; IN_512] = [__v_16, __v_19, __v_1, __v_30, __v_8, __v_9]; 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 __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_16, __v_19, __v_1, __v_30, __v_8, __v_9]; 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)? } };
             if (__v_17 != __v_1) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
             }
@@ -44675,9 +43613,9 @@ fn aiur_fn_504(
             }
             let __v_31: G = G::from_u64(1);
             let __v_32: G = (__v_7 + __v_31);
-            let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__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[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 __ret: [G; OUT_504] = [];
-            record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__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[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 __ret: [G; OUT_490] = [];
+            record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44686,8 +43624,8 @@ fn aiur_fn_504(
             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_504] = [];
-            record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_490] = [];
+            record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44699,22 +43637,22 @@ fn aiur_fn_504(
   })
 }
 
-const INPUT_SIZE_505: usize = 2;
-const IN_505: usize = 2;
-const OUT_505: usize = 1;
-fn aiur_fn_505(
-  inp: [G; IN_505],
+const INPUT_SIZE_491: usize = 2;
+const IN_491: usize = 2;
+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_505], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_505] = [__v_0];
-        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_491] = [__v_0];
+        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44727,10 +43665,10 @@ fn aiur_fn_505(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_505] = [__v_8];
-            record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_491] = [__v_8];
+            record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44742,29 +43680,29 @@ fn aiur_fn_505(
   })
 }
 
-const INPUT_SIZE_506: usize = 3;
-const IN_506: usize = 3;
-const OUT_506: usize = 0;
-fn aiur_fn_506(
-  inp: [G; IN_506],
+const INPUT_SIZE_492: usize = 3;
+const IN_492: usize = 3;
+const OUT_492: usize = 0;
+fn aiur_fn_492(
+  inp: [G; IN_492],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_506], ExecError> {
+) -> 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 __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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_506] = [];
-        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_492] = [];
+        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44784,12 +43722,12 @@ fn aiur_fn_506(
                 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_506] = { let __args: [G; IN_506] = [__v_5, __v_10, __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 __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_10, __v_12]; 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)? } };
                 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_506] = [];
-                record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_492] = [];
+                record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -44806,15 +43744,15 @@ fn aiur_fn_506(
   })
 }
 
-const INPUT_SIZE_507: usize = 4;
-const IN_507: usize = 4;
-const OUT_507: usize = 0;
-fn aiur_fn_507(
-  inp: [G; IN_507],
+const INPUT_SIZE_493: usize = 4;
+const IN_493: usize = 4;
+const OUT_493: usize = 0;
+fn aiur_fn_493(
+  inp: [G; IN_493],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_507], ExecError> {
+) -> 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];
@@ -44823,8 +43761,8 @@ fn aiur_fn_507(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_507] = [];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_493] = [];
+        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44843,7 +43781,7 @@ fn aiur_fn_507(
               0u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = (__v_3 + __v_12);
-                let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_7, __v_1, __v_2, __v_13]; 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 __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_7, __v_1, __v_2, __v_13]; 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 = (__v_2 + __v_1);
                 let __v_15: G = G::from_u64(1);
                 let __v_16: G = (__v_14 - __v_15);
@@ -44851,8 +43789,8 @@ fn aiur_fn_507(
                 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_507] = [];
-                record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_493] = [];
+                record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -44869,22 +43807,22 @@ fn aiur_fn_507(
   })
 }
 
-const INPUT_SIZE_508: usize = 5;
-const IN_508: usize = 5;
-const OUT_508: usize = 1;
-fn aiur_fn_508(
-  inp: [G; IN_508],
+const INPUT_SIZE_494: usize = 5;
+const IN_494: usize = 5;
+const OUT_494: usize = 1;
+fn aiur_fn_494(
+  inp: [G; IN_494],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_508], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_2, __v_3, __v_4]; 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_5: G = __r_arr[0];
     match __v_1.as_canonical_u64() {
       0u64 => {
@@ -44895,8 +43833,8 @@ fn aiur_fn_508(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_508] = [__v_7];
-            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_494] = [__v_7];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44916,10 +43854,10 @@ fn aiur_fn_508(
             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_508] = { let __args: [G; IN_508] = [__v_8, __v_11, __v_13, __v_3, __v_4]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_8, __v_11, __v_13, __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_14: G = __r_arr[0];
-            let __ret: [G; OUT_508] = [__v_14];
-            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_494] = [__v_14];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44931,15 +43869,15 @@ fn aiur_fn_508(
   })
 }
 
-const INPUT_SIZE_509: usize = 6;
-const IN_509: usize = 6;
-const OUT_509: usize = 0;
-fn aiur_fn_509(
-  inp: [G; IN_509],
+const INPUT_SIZE_495: usize = 6;
+const IN_495: usize = 6;
+const OUT_495: usize = 0;
+fn aiur_fn_495(
+  inp: [G; IN_495],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_509], 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];
@@ -44953,29 +43891,29 @@ fn aiur_fn_509(
     let __v_8: G = __loaded[2];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_509] = [];
-        record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_495] = [];
+        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_509] = [];
-        record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_495] = [];
+        record.function_queries[495].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 = 0;
-fn aiur_fn_510(
-  inp: [G; IN_510],
+const INPUT_SIZE_496: usize = 6;
+const IN_496: usize = 6;
+const OUT_496: usize = 0;
+fn aiur_fn_496(
+  inp: [G; IN_496],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_510], 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];
@@ -44985,9 +43923,9 @@ fn aiur_fn_510(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_2, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_510] = [];
-        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_2, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_496] = [];
+        record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45002,9 +43940,9 @@ fn aiur_fn_510(
             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_510] = { let __args: [G; IN_510] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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 __ret: [G; OUT_510] = [];
-            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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 __ret: [G; OUT_496] = [];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45016,15 +43954,15 @@ fn aiur_fn_510(
   })
 }
 
-const INPUT_SIZE_511: usize = 5;
-const IN_511: usize = 5;
-const OUT_511: usize = 0;
-fn aiur_fn_511(
-  inp: [G; IN_511],
+const INPUT_SIZE_497: usize = 5;
+const IN_497: usize = 5;
+const OUT_497: usize = 0;
+fn aiur_fn_497(
+  inp: [G; IN_497],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_511], 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];
@@ -45038,9 +43976,9 @@ fn aiur_fn_511(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_2, __v_3, __v_4]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __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 __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 } };
@@ -45048,29 +43986,29 @@ fn aiur_fn_511(
         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_511] = { let __args: [G; IN_511] = [__v_7, __v_1, __v_12, __v_3, __v_4]; 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 __ret: [G; OUT_511] = [];
-        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_7, __v_1, __v_12, __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 __ret: [G; OUT_497] = [];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_511] = [];
-        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_497] = [];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_512: usize = 6;
-const IN_512: usize = 6;
-const OUT_512: usize = 0;
-fn aiur_fn_512(
-  inp: [G; IN_512],
+const INPUT_SIZE_498: usize = 6;
+const IN_498: usize = 6;
+const OUT_498: usize = 0;
+fn aiur_fn_498(
+  inp: [G; IN_498],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_512], 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];
@@ -45078,34 +44016,34 @@ fn aiur_fn_512(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_1, __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 __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_3]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_4]; 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_6, __v_8, __v_7, __v_4, __v_5]; 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_512] = [];
-    record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_6, __v_8, __v_7, __v_4, __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 __ret: [G; OUT_498] = [];
+    record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_513: usize = 2;
-const IN_513: usize = 2;
-const OUT_513: usize = 1;
-fn aiur_fn_513(
-  inp: [G; IN_513],
+const INPUT_SIZE_499: usize = 2;
+const IN_499: usize = 2;
+const OUT_499: usize = 1;
+fn aiur_fn_499(
+  inp: [G; IN_499],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_513], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_513] = [__v_0];
-        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_499] = [__v_0];
+        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45118,15 +44056,15 @@ fn aiur_fn_513(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_513] = [__v_8];
-            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_499] = [__v_8];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_513] = [__v_0];
-            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_499] = [__v_0];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45135,23 +44073,23 @@ fn aiur_fn_513(
   })
 }
 
-const INPUT_SIZE_514: usize = 3;
-const IN_514: usize = 3;
-const OUT_514: usize = 2;
-fn aiur_fn_514(
-  inp: [G; IN_514],
+const INPUT_SIZE_500: usize = 3;
+const IN_500: usize = 3;
+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_514], ExecError> {
+) -> 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_514] = [__v_0, __v_2];
-        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_500] = [__v_0, __v_2];
+        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45166,16 +44104,16 @@ fn aiur_fn_514(
             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_514] = { let __args: [G; IN_514] = [__v_5, __v_10, __v_8]; 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_500] = { let __args: [G; IN_500] = [__v_5, __v_10, __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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_514] = [__v_11, __v_12];
-            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_500] = [__v_11, __v_12];
+            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_514] = [__v_0, __v_2];
-            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_500] = [__v_0, __v_2];
+            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45184,15 +44122,15 @@ fn aiur_fn_514(
   })
 }
 
-const INPUT_SIZE_515: usize = 5;
-const IN_515: usize = 5;
-const OUT_515: usize = 0;
-fn aiur_fn_515(
-  inp: [G; IN_515],
+const INPUT_SIZE_501: usize = 5;
+const IN_501: usize = 5;
+const OUT_501: usize = 0;
+fn aiur_fn_501(
+  inp: [G; IN_501],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_515], ExecError> {
+) -> 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];
@@ -45206,48 +44144,48 @@ fn aiur_fn_515(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_6, __v_1, __v_2, __v_3, __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_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_515] = { let __args: [G; IN_515] = [__v_7, __v_1, __v_10, __v_3, __v_4]; 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));
+        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_7, __v_1, __v_10, __v_3, __v_4]; 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 __ret: [G; OUT_501] = [];
+        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_515] = [];
-        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_501] = [];
+        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_516: usize = 5;
-const IN_516: usize = 5;
-const OUT_516: usize = 0;
-fn aiur_fn_516(
-  inp: [G; IN_516],
+const INPUT_SIZE_502: usize = 5;
+const IN_502: usize = 5;
+const OUT_502: usize = 0;
+fn aiur_fn_502(
+  inp: [G; IN_502],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_516], 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 __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_0, __v_1]; 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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_516] = [];
-        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_502] = [];
+        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_2, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_2, __v_3, __v_4]; 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];
         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];
@@ -45258,19 +44196,19 @@ fn aiur_fn_516(
           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_521] = { let __args: [G; IN_521] = [__v_8, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_8, __v_1]; 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_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_516] = { let __args: [G; IN_516] = [__v_9, __v_1, __v_12, __v_3, __v_4]; 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 __ret: [G; OUT_516] = [];
-            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_9, __v_1, __v_12, __v_3, __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 __ret: [G; OUT_502] = [];
+            record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6]; 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 __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 };
@@ -45280,16 +44218,16 @@ fn aiur_fn_516(
             let __v_16: G = __loaded[3];
             match __v_13.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_14]; 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_503] = { let __args: [G; IN_503] = [__v_1, __v_14]; 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_17: G = __r_arr[0];
                 match __v_17.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_516] = [];
-                    record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_502] = [];
+                    record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_14]; 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 __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];
@@ -45305,19 +44243,19 @@ fn aiur_fn_516(
                     let __v_29: G = __loaded[10];
                     match __v_19.as_canonical_u64() {
                       5u64 => {
-                        let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_12, __v_22]; 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_769] = { let __args: [G; IN_769] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
                         let __v_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_1, __v_26, __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 __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_1, __v_26, __v_3]; 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_31: G = __r_arr[0];
-                        let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_30, __v_1]; 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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_30, __v_1]; 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_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_525] = { let __args: [G; IN_525] = [__v_24, __v_12, __v_31, __v_3, __v_4]; 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_516] = [];
-                        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_24, __v_12, __v_31, __v_3, __v_4]; 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 __ret: [G; OUT_502] = [];
+                        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -45326,8 +44264,8 @@ fn aiur_fn_516(
                         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_516] = [];
-                        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_502] = [];
+                        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -45343,8 +44281,8 @@ fn aiur_fn_516(
                 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_516] = [];
-                record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_502] = [];
+                record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -45355,15 +44293,15 @@ fn aiur_fn_516(
   })
 }
 
-const INPUT_SIZE_517: usize = 2;
-const IN_517: usize = 2;
-const OUT_517: usize = 1;
-fn aiur_fn_517(
-  inp: [G; IN_517],
+const INPUT_SIZE_503: usize = 2;
+const IN_503: usize = 2;
+const OUT_503: usize = 1;
+fn aiur_fn_503(
+  inp: [G; IN_503],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_517], ExecError> {
+) -> 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];
@@ -45374,8 +44312,8 @@ fn aiur_fn_517(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_517] = [__v_5];
-        record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_503] = [__v_5];
+        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -45383,15 +44321,15 @@ fn aiur_fn_517(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_517] = [__v_6];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_503] = [__v_6];
+            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_4, __v_1]; 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_503] = { let __args: [G; IN_503] = [__v_4, __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_6: G = __r_arr[0];
-            let __ret: [G; OUT_517] = [__v_6];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_503] = [__v_6];
+            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45403,19 +44341,19 @@ fn aiur_fn_517(
   })
 }
 
-const INPUT_SIZE_518: usize = 2;
-const IN_518: usize = 2;
-const OUT_518: usize = 1;
-fn aiur_fn_518(
-  inp: [G; IN_518],
+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_518], ExecError> {
+) -> 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_781] = { let __args: [G; IN_781] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_0]; 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 __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];
@@ -45431,33 +44369,33 @@ fn aiur_fn_518(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1]; 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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_8, __v_6, __v_14, __v_1]; 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 __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_8, __v_6, __v_14, __v_1]; 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_518] = [__v_15];
-        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_504] = [__v_15];
+        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_518] = [__v_14];
-        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_504] = [__v_14];
+        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_519: usize = 4;
-const IN_519: usize = 4;
-const OUT_519: usize = 1;
-fn aiur_fn_519(
-  inp: [G; IN_519],
+const INPUT_SIZE_505: usize = 4;
+const IN_505: usize = 4;
+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_519], 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];
@@ -45470,12 +44408,12 @@ fn aiur_fn_519(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_519] = [__v_7];
-        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_505] = [__v_7];
+        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_5]; 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 __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];
@@ -45491,22 +44429,22 @@ fn aiur_fn_519(
         let __v_18: G = __loaded[10];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_10, __v_1]; 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_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_19, __v_2]; 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 __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_19, __v_2]; 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_20: G = __r_arr[0];
             match __v_20.as_canonical_u64() {
               1u64 => {
                 let __v_21: G = G::from_u64(1);
-                let __ret: [G; OUT_519] = [__v_21];
-                record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_505] = [__v_21];
+                record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_6, __v_1, __v_2, __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 __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_6, __v_1, __v_2, __v_3]; 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_21: G = __r_arr[0];
-                let __ret: [G; OUT_519] = [__v_21];
-                record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_505] = [__v_21];
+                record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45515,10 +44453,10 @@ fn aiur_fn_519(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_6, __v_1, __v_2, __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 __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_6, __v_1, __v_2, __v_3]; 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_19: G = __r_arr[0];
-            let __ret: [G; OUT_519] = [__v_19];
-            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_505] = [__v_19];
+            record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45530,15 +44468,15 @@ fn aiur_fn_519(
   })
 }
 
-const INPUT_SIZE_520: usize = 2;
-const IN_520: usize = 2;
-const OUT_520: usize = 1;
-fn aiur_fn_520(
-  inp: [G; IN_520],
+const INPUT_SIZE_506: usize = 2;
+const IN_506: usize = 2;
+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_520], ExecError> {
+) -> 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];
@@ -45549,20 +44487,20 @@ fn aiur_fn_520(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_3, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_520] = [__v_7];
-            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_506] = [__v_7];
+            record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_520] = [__v_7];
-            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_506] = [__v_7];
+            record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45572,23 +44510,23 @@ fn aiur_fn_520(
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_520] = [__v_6];
-        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_506] = [__v_6];
+        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_521: usize = 2;
-const IN_521: usize = 2;
-const OUT_521: usize = 1;
-fn aiur_fn_521(
-  inp: [G; IN_521],
+const INPUT_SIZE_507: usize = 2;
+const IN_507: usize = 2;
+const OUT_507: usize = 1;
+fn aiur_fn_507(
+  inp: [G; IN_507],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_521], ExecError> {
+) -> 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];
@@ -45600,38 +44538,38 @@ fn aiur_fn_521(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_521] = [__v_6];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [__v_6];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_521] = [__v_6];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [__v_6];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_3]; 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_503] = { let __args: [G; IN_503] = [__v_1, __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_6: G = __r_arr[0];
-        let __ret: [G; OUT_521] = [__v_6];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [__v_6];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_3, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_521] = [__v_7];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_7];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_521] = [__v_7];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_7];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45640,20 +44578,20 @@ fn aiur_fn_521(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_3, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_521] = [__v_7];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_7];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_521] = [__v_7];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_7];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45662,20 +44600,20 @@ fn aiur_fn_521(
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_3, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_521] = [__v_7];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_7];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_521] = [__v_7];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_7];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45684,30 +44622,30 @@ fn aiur_fn_521(
         }
       },
       6u64 => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_3, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_521] = [__v_7];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_7];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_521] = [__v_8];
-                record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_507] = [__v_8];
+                record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_5, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_5, __v_1]; 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 __ret: [G; OUT_521] = [__v_8];
-                record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_507] = [__v_8];
+                record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45722,15 +44660,15 @@ fn aiur_fn_521(
       },
       7u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_521] = [__v_6];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [__v_6];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_5, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_5, __v_1]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_521] = [__v_6];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [__v_6];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45740,15 +44678,15 @@ fn aiur_fn_521(
   })
 }
 
-const INPUT_SIZE_522: usize = 2;
-const IN_522: usize = 2;
-const OUT_522: usize = 1;
-fn aiur_fn_522(
-  inp: [G; IN_522],
+const INPUT_SIZE_508: usize = 2;
+const IN_508: usize = 2;
+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_522], 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];
@@ -45759,25 +44697,25 @@ fn aiur_fn_522(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_522] = [__v_5];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_508] = [__v_5];
+        record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_3, __v_1]; 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_507] = { let __args: [G; IN_507] = [__v_3, __v_1]; 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_522] = [__v_6];
-            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_508] = [__v_6];
+            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_4, __v_1]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_522] = [__v_6];
-            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_508] = [__v_6];
+            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45792,37 +44730,37 @@ fn aiur_fn_522(
   })
 }
 
-const INPUT_SIZE_523: usize = 3;
-const IN_523: usize = 3;
-const OUT_523: usize = 1;
-fn aiur_fn_523(
-  inp: [G; IN_523],
+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_523], ExecError> {
+) -> 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 __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2, __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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __v_2, __v_3]; 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_4: G = __r_arr[0];
-    let __ret: [G; OUT_523] = [__v_4];
-    record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_509] = [__v_4];
+    record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_524: usize = 4;
-const IN_524: usize = 4;
-const OUT_524: usize = 1;
-fn aiur_fn_524(
-  inp: [G; IN_524],
+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_524], ExecError> {
+) -> 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];
@@ -45834,8 +44772,8 @@ fn aiur_fn_524(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_524] = [__v_0];
-        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_510] = [__v_0];
+        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -45853,7 +44791,7 @@ fn aiur_fn_524(
         let __v_17: G = __loaded[10];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1]; 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 __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);
@@ -45889,10 +44827,10 @@ fn aiur_fn_524(
             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_130] = { let __args: [G; IN_130] = [__v_1, __v_52]; 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 __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_517] = { let __args: [G; IN_517] = [__v_0, __v_3]; 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_503] = { let __args: [G; IN_503] = [__v_0, __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_55: G = __r_arr[0];
             let __v_56: G = G::from_u64(1);
             let __v_57: G = (__v_56 - __v_55);
@@ -45904,19 +44842,19 @@ fn aiur_fn_524(
                 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_524] = { let __args: [G; IN_524] = [__v_61, __v_1, __v_6, __v_63]; 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_510] = { let __args: [G; IN_510] = [__v_61, __v_1, __v_6, __v_63]; 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_64: G = __r_arr[0];
-                let __ret: [G; OUT_524] = [__v_64];
-                record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_510] = [__v_64];
+                record.function_queries[510].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_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_6, __v_61]; 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_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __v_6, __v_61]; 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_62: G = __r_arr[0];
-                let __ret: [G; OUT_524] = [__v_62];
-                record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_510] = [__v_62];
+                record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45927,10 +44865,10 @@ fn aiur_fn_524(
           _ => {
             let __v_18: G = G::from_u64(1);
             let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_6, __v_19]; 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_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __v_6, __v_19]; 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_20: G = __r_arr[0];
-            let __ret: [G; OUT_524] = [__v_20];
-            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_510] = [__v_20];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45942,15 +44880,15 @@ fn aiur_fn_524(
   })
 }
 
-const INPUT_SIZE_525: usize = 5;
-const IN_525: usize = 5;
-const OUT_525: usize = 0;
-fn aiur_fn_525(
-  inp: [G; IN_525],
+const INPUT_SIZE_511: usize = 5;
+const IN_511: usize = 5;
+const OUT_511: usize = 0;
+fn aiur_fn_511(
+  inp: [G; IN_511],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_525], ExecError> {
+) -> 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];
@@ -45963,12 +44901,12 @@ fn aiur_fn_525(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_525] = [];
-        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_511] = [];
+        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_6]; 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 __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];
@@ -45987,19 +44925,19 @@ fn aiur_fn_525(
             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_514] = { let __args: [G; IN_514] = [__v_11, __v_14, __v_22]; 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_500] = { let __args: [G; IN_500] = [__v_11, __v_14, __v_22]; 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
-            let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_23, __v_2, __v_24, __v_3, __v_4]; 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 __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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));
+            let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_23, __v_2, __v_24, __v_3, __v_4]; 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 __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_511] = [];
+            record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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));
+            let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_511] = [];
+            record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46011,159 +44949,44 @@ fn aiur_fn_525(
   })
 }
 
-const INPUT_SIZE_526: usize = 2;
-const IN_526: usize = 2;
-const OUT_526: usize = 1;
-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 __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 __ret: [G; OUT_526] = [__v_6];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_526] = [__v_6];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __v_6: G = (__v_3 - __v_1);
-        match __v_6.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_526] = [__v_7];
-            record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_526] = [__v_7];
-            record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_3, __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 __v_6: G = __r_arr[0];
-        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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_526] = [__v_8];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_3, __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 __v_6: G = __r_arr[0];
-        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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_526] = [__v_8];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_3, __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 __v_6: G = __r_arr[0];
-        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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_526] = [__v_8];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_3, __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 __v_6: G = __r_arr[0];
-        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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_5, __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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_6, __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_10: G = __r_arr[0];
-        let __ret: [G; OUT_526] = [__v_10];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_526] = [__v_6];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_5, __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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_526] = [__v_6];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_527: usize = 4;
-const IN_527: usize = 4;
-const OUT_527: usize = 1;
-fn aiur_fn_527(
-  inp: [G; IN_527],
+const INPUT_SIZE_512: usize = 4;
+const IN_512: usize = 4;
+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_527], ExecError> {
+) -> 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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0]; 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 __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 __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_527] = [__v_5];
-        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_512] = [__v_5];
+        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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_527] = [__v_6];
-            record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_512] = [__v_6];
+            record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_6]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_6]; 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 __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_7]; 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 __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];
@@ -46182,18 +45005,18 @@ fn aiur_fn_527(
                 match __v_15.as_canonical_u64() {
                   0u64 => {
                     let __v_20: G = G::from_u64(1);
-                    let __ret: [G; OUT_527] = [__v_20];
-                    record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_512] = [__v_20];
+                    record.function_queries[512].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_528] = { let __args: [G; IN_528] = [__v_11, __v_14, __v_15, __v_22, __v_2, __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_513] = { let __args: [G; IN_513] = [__v_11, __v_14, __v_15, __v_22, __v_2, __v_3]; 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_23: G = __r_arr[0];
-                    let __ret: [G; OUT_527] = [__v_23];
-                    record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_512] = [__v_23];
+                    record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -46205,8 +45028,8 @@ fn aiur_fn_527(
           },
           _ => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_527] = [__v_6];
-            record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_512] = [__v_6];
+            record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46218,15 +45041,15 @@ fn aiur_fn_527(
   })
 }
 
-const INPUT_SIZE_528: usize = 6;
-const IN_528: usize = 6;
-const OUT_528: usize = 1;
-fn aiur_fn_528(
-  inp: [G; IN_528],
+const INPUT_SIZE_513: usize = 6;
+const IN_513: usize = 6;
+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_528], 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];
@@ -46240,10 +45063,10 @@ fn aiur_fn_528(
         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_529] = { let __args: [G; IN_529] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; 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 __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_528] = [__v_10];
-        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_513] = [__v_10];
+        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46258,16 +45081,16 @@ fn aiur_fn_528(
             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_528] = { let __args: [G; IN_528] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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_513] = { let __args: [G; IN_513] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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_14: G = __r_arr[0];
-            let __ret: [G; OUT_528] = [__v_14];
-            record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_513] = [__v_14];
+            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_528] = [__v_10];
-            record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_513] = [__v_10];
+            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46276,15 +45099,15 @@ fn aiur_fn_528(
   })
 }
 
-const INPUT_SIZE_529: usize = 7;
-const IN_529: usize = 7;
-const OUT_529: usize = 1;
-fn aiur_fn_529(
-  inp: [G; IN_529],
+const INPUT_SIZE_514: usize = 7;
+const IN_514: usize = 7;
+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_529], 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];
@@ -46296,13 +45119,13 @@ fn aiur_fn_529(
     let __v_7: G = (__v_1 - __v_2);
     match __v_7.as_canonical_u64() {
       0u64 => {
-        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 __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_530] = { let __args: [G; IN_530] = [__v_6, __v_9]; 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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_6, __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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_529] = [__v_10];
-        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_514] = [__v_10];
+        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46313,13 +45136,13 @@ fn aiur_fn_529(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_9, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_3, __v_4, __v_5]; 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_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_229] = { let __args: [G; IN_229] = [__v_12, __v_16]; 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 __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);
@@ -46341,16 +45164,16 @@ fn aiur_fn_529(
             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_529] = { let __args: [G; IN_529] = [__v_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; 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 __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; 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_27: G = __r_arr[0];
-            let __ret: [G; OUT_529] = [__v_27];
-            record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_514] = [__v_27];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __ret: [G; OUT_529] = [__v_12];
-            record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_514] = [__v_12];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46359,15 +45182,15 @@ fn aiur_fn_529(
   })
 }
 
-const INPUT_SIZE_530: usize = 2;
-const IN_530: usize = 2;
-const OUT_530: usize = 1;
-fn aiur_fn_530(
-  inp: [G; IN_530],
+const INPUT_SIZE_515: usize = 2;
+const IN_515: usize = 2;
+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_530], 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];
@@ -46378,25 +45201,25 @@ fn aiur_fn_530(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_530] = [__v_5];
-        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [__v_5];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_1, __v_3]; 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_530] = [__v_6];
-            record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_515] = [__v_6];
+            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_4, __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 __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_4, __v_1]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_530] = [__v_6];
-            record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_515] = [__v_6];
+            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46411,15 +45234,15 @@ fn aiur_fn_530(
   })
 }
 
-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_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_531], 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];
@@ -46430,8 +45253,8 @@ fn aiur_fn_531(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_531] = [__v_5];
-        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_516] = [__v_5];
+        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -46446,24 +45269,24 @@ fn aiur_fn_531(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_531] = [__v_10];
-                record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_516] = [__v_10];
+                record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_4, __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_10: G = __r_arr[0];
-                let __ret: [G; OUT_531] = [__v_10];
-                record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_516] = [__v_10];
+                record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_4, __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_9: G = __r_arr[0];
-            let __ret: [G; OUT_531] = [__v_9];
-            record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_516] = [__v_9];
+            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46475,15 +45298,15 @@ fn aiur_fn_531(
   })
 }
 
-const INPUT_SIZE_532: usize = 11;
-const IN_532: usize = 11;
-const OUT_532: usize = 1;
-fn aiur_fn_532(
-  inp: [G; IN_532],
+const INPUT_SIZE_517: usize = 11;
+const IN_517: usize = 11;
+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_532], 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];
@@ -46496,20 +45319,20 @@ fn aiur_fn_532(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_4]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1, __v_4]; 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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_11, __v_2, __v_6, __v_7, __v_8, __v_12]; 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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_11, __v_2, __v_6, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_13, __v_3, __v_9, __v_10]; 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_526] = { let __args: [G; IN_526] = [__v_13, __v_3, __v_9, __v_10]; 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 __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_533] = { let __args: [G; IN_533] = [__v_17, __v_6, __v_3, __v_7, __v_8]; 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_518] = { let __args: [G; IN_518] = [__v_17, __v_6, __v_3, __v_7, __v_8]; 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_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(0);
-    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_18, __v_3, __v_19]; 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 __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_18, __v_3, __v_19]; 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_20: G = __r_arr[0];
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(0);
@@ -46517,23 +45340,23 @@ fn aiur_fn_532(
     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_545] = { let __args: [G; IN_545] = [__v_26, __v_14]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_26, __v_14]; 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_27: G = __r_arr[0];
-    let __ret: [G; OUT_532] = [__v_27];
-    record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_517] = [__v_27];
+    record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_533: usize = 5;
-const IN_533: usize = 5;
-const OUT_533: usize = 1;
-fn aiur_fn_533(
-  inp: [G; IN_533],
+const INPUT_SIZE_518: usize = 5;
+const IN_518: usize = 5;
+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_533], 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];
@@ -46543,32 +45366,32 @@ fn aiur_fn_533(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_0, __v_1, __v_2, __v_5]; 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 __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_0, __v_1, __v_2, __v_5]; 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_533] = [__v_6];
-        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_518] = [__v_6];
+        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_4, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_4, __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_5: G = __r_arr[0];
-        let __ret: [G; OUT_533] = [__v_5];
-        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_518] = [__v_5];
+        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_534: usize = 3;
-const IN_534: usize = 3;
-const OUT_534: usize = 1;
-fn aiur_fn_534(
-  inp: [G; IN_534],
+const INPUT_SIZE_519: usize = 3;
+const IN_519: usize = 3;
+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_534], ExecError> {
+) -> Result<[G; OUT_519], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46579,21 +45402,21 @@ fn aiur_fn_534(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_534] = [__v_0];
-        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_519] = [__v_0];
+        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_2, __v_6]; 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_386] = { let __args: [G; IN_386] = [__v_4, __v_2, __v_6]; 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_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_534] = { let __args: [G; IN_534] = [__v_10, __v_5, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_10, __v_5, __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_11: G = __r_arr[0];
-        let __ret: [G; OUT_534] = [__v_11];
-        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_519] = [__v_11];
+        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46603,15 +45426,15 @@ fn aiur_fn_534(
   })
 }
 
-const INPUT_SIZE_535: usize = 6;
-const IN_535: usize = 6;
-const OUT_535: usize = 1;
-fn aiur_fn_535(
-  inp: [G; IN_535],
+const INPUT_SIZE_520: usize = 6;
+const IN_520: usize = 6;
+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_535], 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];
@@ -46621,8 +45444,8 @@ fn aiur_fn_535(
     let __v_5: G = inp[5];
     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));
+        let __ret: [G; OUT_520] = [__v_0];
+        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46633,19 +45456,19 @@ fn aiur_fn_535(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_5, __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 __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_5, __v_2, __v_3, __v_4]; 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 __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_10, __v_11]; 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_392] = { let __args: [G; IN_392] = [__v_8, __v_10, __v_11]; 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_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_535] = { let __args: [G; IN_535] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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_17: G = __r_arr[0];
-            let __ret: [G; OUT_535] = [__v_17];
-            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_520] = [__v_17];
+            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46657,15 +45480,15 @@ fn aiur_fn_535(
   })
 }
 
-const INPUT_SIZE_536: usize = 4;
-const IN_536: usize = 4;
-const OUT_536: usize = 1;
-fn aiur_fn_536(
-  inp: [G; IN_536],
+const INPUT_SIZE_521: usize = 4;
+const IN_521: usize = 4;
+const OUT_521: usize = 1;
+fn aiur_fn_521(
+  inp: [G; IN_521],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_536], ExecError> {
+) -> Result<[G; OUT_521], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46679,20 +45502,20 @@ fn aiur_fn_536(
         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_536] = [__v_9];
-        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_521] = [__v_9];
+        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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_781] = { let __args: [G; IN_781] = [__v_3, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_0]; 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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_536] = [__v_6];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_6];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46702,8 +45525,8 @@ fn aiur_fn_536(
             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_536] = [__v_11];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_11];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46712,15 +45535,15 @@ fn aiur_fn_536(
   })
 }
 
-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_522: usize = 4;
+const IN_522: usize = 4;
+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_537], 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];
@@ -46728,10 +45551,10 @@ fn aiur_fn_537(
     let __v_3: G = inp[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_1]; 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_537] = [__v_4];
-        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_522] = [__v_4];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46739,29 +45562,29 @@ fn aiur_fn_537(
         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_539] = { let __args: [G; IN_539] = [__v_0, __v_1, __v_4, __v_5, __v_6, __v_3, __v_7]; 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_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_4, __v_5, __v_6, __v_3, __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_537] = [__v_8];
-        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_522] = [__v_8];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_538: usize = 2;
-const IN_538: usize = 2;
-const OUT_538: usize = 1;
-fn aiur_fn_538(
-  inp: [G; IN_538],
+const INPUT_SIZE_523: usize = 2;
+const IN_523: usize = 2;
+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_538], ExecError> {
+) -> Result<[G; OUT_523], 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_781] = { let __args: [G; IN_781] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_0]; 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 __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];
@@ -46777,29 +45600,29 @@ fn aiur_fn_538(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       6u64 => {
-        let __ret: [G; OUT_538] = [__v_8];
-        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_523] = [__v_8];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_538] = [__v_14];
-        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_523] = [__v_14];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_524: usize = 7;
+const IN_524: usize = 7;
+const OUT_524: usize = 1;
+fn aiur_fn_524(
+  inp: [G; IN_524],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_539], 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];
@@ -46810,8 +45633,8 @@ fn aiur_fn_539(
     let __v_6: G = inp[6];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_539] = [__v_0];
-        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_524] = [__v_0];
+        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46822,19 +45645,19 @@ fn aiur_fn_539(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_6, __v_2, __v_3, __v_4, __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 __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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 = G::from_u64(0);
-            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_9, __v_11, __v_12]; 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_392] = { let __args: [G; IN_392] = [__v_9, __v_11, __v_12]; 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_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_539] = { let __args: [G; IN_539] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; 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_524] = { let __args: [G; IN_524] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; 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_18: G = __r_arr[0];
-            let __ret: [G; OUT_539] = [__v_18];
-            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_524] = [__v_18];
+            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46846,15 +45669,15 @@ fn aiur_fn_539(
   })
 }
 
-const INPUT_SIZE_540: usize = 5;
-const IN_540: usize = 5;
-const OUT_540: usize = 1;
-fn aiur_fn_540(
-  inp: [G; IN_540],
+const INPUT_SIZE_525: usize = 5;
+const IN_525: usize = 5;
+const OUT_525: usize = 1;
+fn aiur_fn_525(
+  inp: [G; IN_525],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_540], 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];
@@ -46869,23 +45692,23 @@ fn aiur_fn_540(
         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_540] = [__v_10];
-        record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_525] = [__v_10];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; 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 __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_781] = { let __args: [G; IN_781] = [__v_4, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_0]; 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 __v_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_7, __v_2, __v_8]; 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_386] = { let __args: [G; IN_386] = [__v_7, __v_2, __v_8]; 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_9: G = __r_arr[0];
-            let __ret: [G; OUT_540] = [__v_9];
-            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_525] = [__v_9];
+            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46895,8 +45718,8 @@ fn aiur_fn_540(
             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_540] = [__v_12];
-            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_525] = [__v_12];
+            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46905,15 +45728,15 @@ fn aiur_fn_540(
   })
 }
 
-const INPUT_SIZE_541: usize = 4;
-const IN_541: usize = 4;
-const OUT_541: usize = 1;
-fn aiur_fn_541(
-  inp: [G; IN_541],
+const INPUT_SIZE_526: usize = 4;
+const IN_526: usize = 4;
+const OUT_526: usize = 1;
+fn aiur_fn_526(
+  inp: [G; IN_526],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_541], 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];
@@ -46924,15 +45747,15 @@ fn aiur_fn_541(
         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_541] = [__v_6];
-        record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_526] = [__v_6];
+        record.function_queries[526].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_428] = { let __args: [G; IN_428] = [__v_0, __v_6, __v_2, __v_3]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_6, __v_2, __v_3]; 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_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];
@@ -46944,11 +45767,11 @@ fn aiur_fn_541(
             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_541] = { let __args: [G; IN_541] = [__v_10, __v_14, __v_2, __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 __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_10, __v_14, __v_2, __v_3]; 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 __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_541] = [__v_16];
-            record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_526] = [__v_16];
+            record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46960,15 +45783,15 @@ fn aiur_fn_541(
   })
 }
 
-const INPUT_SIZE_542: usize = 3;
-const IN_542: usize = 3;
-const OUT_542: usize = 1;
-fn aiur_fn_542(
-  inp: [G; IN_542],
+const INPUT_SIZE_527: usize = 3;
+const IN_527: usize = 3;
+const OUT_527: usize = 1;
+fn aiur_fn_527(
+  inp: [G; IN_527],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_542], 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];
@@ -46979,8 +45802,8 @@ fn aiur_fn_542(
         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_542] = [__v_6];
-        record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_527] = [__v_6];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46991,26 +45814,26 @@ fn aiur_fn_542(
         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_542] = { let __args: [G; IN_542] = [__v_0, __v_1, __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 __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_0, __v_1, __v_10]; 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_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_542] = [__v_12];
-        record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_527] = [__v_12];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_543: usize = 4;
-const IN_543: usize = 4;
-const OUT_543: usize = 1;
-fn aiur_fn_543(
-  inp: [G; IN_543],
+const INPUT_SIZE_528: usize = 4;
+const IN_528: usize = 4;
+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_543], ExecError> {
+) -> 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];
@@ -47019,8 +45842,8 @@ fn aiur_fn_543(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_543] = [__v_0];
-        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_528] = [__v_0];
+        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -47036,25 +45859,25 @@ fn aiur_fn_543(
         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_543] = { let __args: [G; IN_543] = [__v_14, __v_1, __v_2, __v_16]; 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 __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_14, __v_1, __v_2, __v_16]; 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];
-        let __ret: [G; OUT_543] = [__v_17];
-        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_528] = [__v_17];
+        record.function_queries[528].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_529: usize = 3;
+const IN_529: usize = 3;
+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_544], ExecError> {
+) -> Result<[G; OUT_529], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47062,8 +45885,8 @@ fn aiur_fn_544(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_544] = [__v_0];
-        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_529] = [__v_0];
+        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -47078,25 +45901,25 @@ fn aiur_fn_544(
         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_544] = { let __args: [G; IN_544] = [__v_12, __v_1, __v_14]; 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 __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_1, __v_14]; 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_544] = [__v_15];
-        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_529] = [__v_15];
+        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_545: usize = 2;
-const IN_545: usize = 2;
-const OUT_545: usize = 1;
-fn aiur_fn_545(
-  inp: [G; IN_545],
+const INPUT_SIZE_530: usize = 2;
+const IN_530: usize = 2;
+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_545], 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];
@@ -47106,18 +45929,18 @@ fn aiur_fn_545(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_545] = [__v_0];
-        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_530] = [__v_0];
+        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(5);
-        let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_4]; 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_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_545] = [__v_8];
-        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_530] = [__v_8];
+        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -47127,15 +45950,15 @@ fn aiur_fn_545(
   })
 }
 
-const INPUT_SIZE_546: usize = 16;
-const IN_546: usize = 16;
-const OUT_546: usize = 1;
-fn aiur_fn_546(
-  inp: [G; IN_546],
+const INPUT_SIZE_531: usize = 16;
+const IN_531: usize = 16;
+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_546], 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];
@@ -47153,15 +45976,15 @@ fn aiur_fn_546(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_2, __v_5]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_2, __v_5]; 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_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_538] = { let __args: [G; IN_538] = [__v_1, __v_14]; 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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_1, __v_14]; 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_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_539] = { let __args: [G; IN_539] = [__v_16, __v_19, __v_18, __v_20, __v_3, __v_4, __v_21]; 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_524] = { let __args: [G; IN_524] = [__v_16, __v_19, __v_18, __v_20, __v_3, __v_4, __v_21]; 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_22: G = __r_arr[0];
     let __v_23: G = G::from_u64(1);
     let __v_24: G = G::from_u64(1);
@@ -47176,24 +45999,24 @@ fn aiur_fn_546(
     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_549] = { let __args: [G; IN_549] = [__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[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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__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[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_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_200] = { let __args: [G; IN_200] = [__v_36]; 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 __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_200] = { let __args: [G; IN_200] = [__v_37]; 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 __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_202] = { let __args: [G; IN_202] = [__v_39]; 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 __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_799] = { let __args: [G; IN_799] = [__v_45, __v_19]; 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_769] = { let __args: [G; IN_769] = [__v_45, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_562] = { let __args: [G; IN_562] = [__v_46, __v_41, __v_47]; 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 __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_46, __v_41, __v_47]; 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_48: G = __r_arr[0];
     let __v_49: G = G::from_u64(1);
     let __v_50: G = (__v_43 - __v_49);
@@ -47202,15 +46025,15 @@ fn aiur_fn_546(
     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_414] = { let __args: [G; IN_414] = [__v_55, __v_48]; 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_400] = { let __args: [G; IN_400] = [__v_55, __v_48]; 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_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_547] = { let __args: [G; IN_547] = [__v_59, __v_19, __v_9, __v_43, __v_3, __v_4]; 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 __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_59, __v_19, __v_9, __v_43, __v_3, __v_4]; 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_60: G = __r_arr[0];
     let __v_61: G = G::from_u64(0);
-    let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_60, __v_40, __v_42, __v_61]; 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_60, __v_40, __v_42, __v_61]; 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_62: G = __r_arr[0];
     let __v_63: G = G::from_u64(3);
     let __v_64: G = G::from_u64(0);
@@ -47219,27 +46042,27 @@ fn aiur_fn_546(
     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_640] = { let __args: [G; IN_640] = [__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[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_621] = { let __args: [G; IN_621] = [__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[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_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_65, __v_70]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_65, __v_70]; 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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_71, __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)? } };
+    let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_71, __v_36]; 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_72: G = __r_arr[0];
-    let __ret: [G; OUT_546] = [__v_72];
-    record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_531] = [__v_72];
+    record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_547: usize = 6;
-const IN_547: usize = 6;
-const OUT_547: usize = 1;
-fn aiur_fn_547(
-  inp: [G; IN_547],
+const INPUT_SIZE_532: usize = 6;
+const IN_532: usize = 6;
+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_547], 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];
@@ -47252,89 +46075,33 @@ fn aiur_fn_547(
         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_563] = { let __args: [G; IN_563] = [__v_0, __v_2, __v_7, __v_8]; 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_2, __v_7, __v_8]; 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_547] = [__v_9];
-        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_532] = [__v_9];
+        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = (__v_3 - __v_2);
-        let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_5, __v_6]; 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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_5, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_547] = [__v_7];
-        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_532] = [__v_7];
+        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_548: usize = 4;
-const IN_548: usize = 4;
-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_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];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_548] = [__v_0];
-        record.function_queries[548].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 = G::from_u64(1);
-            let __v_10: G = (__v_2 - __v_9);
-            let __v_11: G = (__v_10 - __v_3);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 4] = [__v_8, __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 __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_13, __v_14]; 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_15: G = __r_arr[0];
-            let __v_16: G = G::from_u64(1);
-            let __v_17: G = (__v_1 - __v_16);
-            let __v_18: G = G::from_u64(1);
-            let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_15, __v_17, __v_2, __v_19]; 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_20: G = __r_arr[0];
-            let __ret: [G; OUT_548] = [__v_20];
-            record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_549: usize = 10;
-const IN_549: usize = 10;
-const OUT_549: usize = 4;
-fn aiur_fn_549(
-  inp: [G; IN_549],
+const INPUT_SIZE_533: usize = 10;
+const IN_533: usize = 10;
+const OUT_533: usize = 4;
+fn aiur_fn_533(
+  inp: [G; IN_533],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_549], 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];
@@ -47353,7 +46120,7 @@ fn aiur_fn_549(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_11, __v_1, __v_5, __v_6, __v_7, __v_9]; 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_539] = { let __args: [G; IN_539] = [__v_11, __v_1, __v_5, __v_6, __v_7, __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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = G::from_u64(0);
@@ -47368,57 +46135,57 @@ fn aiur_fn_549(
             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_549] = { let __args: [G; IN_549] = [__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[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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__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[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_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_549] = [__v_26, __v_27, __v_28, __v_29];
-            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_533] = [__v_26, __v_27, __v_28, __v_29];
+            record.function_queries[533].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_549] = { let __args: [G; IN_549] = [__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[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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__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[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_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_549] = [__v_22, __v_23, __v_24, __v_25];
-            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_533] = [__v_22, __v_23, __v_24, __v_25];
+            record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_2]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_2]; 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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_3]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_3]; 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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_4]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_4]; 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 __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_549] = [__v_14, __v_15, __v_16, __v_0];
-        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_533] = [__v_14, __v_15, __v_16, __v_0];
+        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_550: usize = 2;
-const IN_550: usize = 2;
-const OUT_550: usize = 1;
-fn aiur_fn_550(
-  inp: [G; IN_550],
+const INPUT_SIZE_534: usize = 2;
+const IN_534: usize = 2;
+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_550], 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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_0]; 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 __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];
@@ -47467,7 +46234,7 @@ fn aiur_fn_550(
         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_130] = { let __args: [G; IN_130] = [__v_10, __v_46]; 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 __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 => {
@@ -47476,30 +46243,30 @@ fn aiur_fn_550(
             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_550] = [__v_52];
-            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_534] = [__v_52];
+            record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_48: G = G::from_u64(0);
-            let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_48]; 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 __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_48]; 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_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_757] = { let __args: [G; IN_757] = [__v_10]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_10]; 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_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_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __v_59: G = __r_arr[0];
-            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_59, __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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_59, __v_10]; 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_60: G = __r_arr[0];
-            let __ret: [G; OUT_550] = [__v_60];
-            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_534] = [__v_60];
+            record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47513,23 +46280,23 @@ fn aiur_fn_550(
         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_550] = [__v_18];
-        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_534] = [__v_18];
+        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_551: usize = 2;
-const IN_551: usize = 2;
-const OUT_551: usize = 6;
-fn aiur_fn_551(
-  inp: [G; IN_551],
+const INPUT_SIZE_535: usize = 2;
+const IN_535: usize = 2;
+const OUT_535: usize = 6;
+fn aiur_fn_535(
+  inp: [G; IN_535],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_551], 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];
@@ -47541,8 +46308,8 @@ fn aiur_fn_551(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_551] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_535] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
+        record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -47560,7 +46327,7 @@ fn aiur_fn_551(
         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_551] = { let __args: [G; IN_551] = [__v_4, __v_17]; 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 __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_17]; 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -47602,24 +46369,24 @@ fn aiur_fn_551(
             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_130] = { let __args: [G; IN_130] = [__v_12, __v_56]; 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 __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() {
               1u64 => {
-                let __ret: [G; OUT_551] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-                record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_535] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+                record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__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[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 __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__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[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_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_551] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-                record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_535] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
+                record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -47628,8 +46395,8 @@ fn aiur_fn_551(
             }
           },
           _ => {
-            let __ret: [G; OUT_551] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-            record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_535] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -47641,15 +46408,15 @@ fn aiur_fn_551(
   })
 }
 
-const INPUT_SIZE_552: usize = 8;
-const IN_552: usize = 8;
-const OUT_552: usize = 6;
-fn aiur_fn_552(
-  inp: [G; IN_552],
+const INPUT_SIZE_536: usize = 8;
+const IN_536: usize = 8;
+const OUT_536: usize = 6;
+fn aiur_fn_536(
+  inp: [G; IN_536],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_552], 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];
@@ -47659,37 +46426,37 @@ fn aiur_fn_552(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_6]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_6]; 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_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_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_12, __v_6, __v_7]; 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 __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_12, __v_6, __v_7]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__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[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_758] = { let __args: [G; IN_758] = [__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[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_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_552] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-    record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_536] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+    record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_553: usize = 3;
-const IN_553: usize = 3;
-const OUT_553: usize = 1;
-fn aiur_fn_553(
-  inp: [G; IN_553],
+const INPUT_SIZE_537: usize = 3;
+const IN_537: usize = 3;
+const OUT_537: usize = 1;
+fn aiur_fn_537(
+  inp: [G; IN_537],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_553], 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];
@@ -47711,12 +46478,12 @@ fn aiur_fn_553(
         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_553] = [__v_16];
-        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_537] = [__v_16];
+        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !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 __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 __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
@@ -47724,17 +46491,17 @@ fn aiur_fn_553(
             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_553] = [__v_11];
-            record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_537] = [__v_11];
+            record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_6, __v_1, __v_2]; 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 __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_6, __v_1, __v_2]; 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_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_553] = [__v_10];
-            record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_537] = [__v_10];
+            record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47749,15 +46516,15 @@ fn aiur_fn_553(
   })
 }
 
-const INPUT_SIZE_554: usize = 2;
-const IN_554: usize = 2;
-const OUT_554: usize = 1;
-fn aiur_fn_554(
-  inp: [G; IN_554],
+const INPUT_SIZE_538: usize = 2;
+const IN_538: usize = 2;
+const OUT_538: usize = 1;
+fn aiur_fn_538(
+  inp: [G; IN_538],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_554], 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];
@@ -47771,24 +46538,24 @@ fn aiur_fn_554(
         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_554] = [__v_8];
-        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_538] = [__v_8];
+        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_1]; 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 __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_554] = [__v_4];
-            record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_538] = [__v_4];
+            record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_5, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_554] = [__v_7];
-            record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_538] = [__v_7];
+            record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47803,132 +46570,15 @@ fn aiur_fn_554(
   })
 }
 
-const INPUT_SIZE_555: usize = 3;
-const IN_555: usize = 3;
-const OUT_555: usize = 1;
-fn aiur_fn_555(
-  inp: [G; IN_555],
-  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 __v_2: G = inp[2];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_1]; 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_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 = 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 = G::from_u64(0);
-        let __v_47: G = { let __values: [G; 32] = [__v_15, __v_16, __v_17, __v_18, __v_19, __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 __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_130] = { let __args: [G; IN_130] = [__v_11, __v_47]; 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_48: G = __r_arr[0];
-        match __v_48.as_canonical_u64() {
-          1u64 => {
-            let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_555] = [__v_49];
-            record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_0]; 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_49: 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_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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-            match __v_50.as_canonical_u64() {
-              5u64 => {
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_57, __v_11]; 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_61: G = __r_arr[0];
-                let __ret: [G; OUT_555] = [__v_61];
-                record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_61: G = G::from_u64(0);
-                let __ret: [G; OUT_555] = [__v_61];
-                record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_48.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_555] = [__v_15];
-        record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_556: usize = 6;
-const IN_556: usize = 6;
-const OUT_556: usize = 2;
-fn aiur_fn_556(
-  inp: [G; IN_556],
+const INPUT_SIZE_539: usize = 6;
+const IN_539: usize = 6;
+const OUT_539: usize = 2;
+fn aiur_fn_539(
+  inp: [G; IN_539],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_556], 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];
@@ -47936,16 +46586,16 @@ fn aiur_fn_556(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0]; 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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_0]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_6]; 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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_8, __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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_8, __v_2]; 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 __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_9, __v_3, __v_4]; 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_414] = { let __args: [G; IN_414] = [__v_7, __v_9, __v_3, __v_4]; 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10]; 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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_10]; 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 };
@@ -47955,37 +46605,37 @@ fn aiur_fn_556(
     let __v_16: G = __loaded[3];
     match __v_13.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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 = (__v_5 + __v_17);
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_14, __v_12, __v_19, __v_18]; 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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_14, __v_12, __v_19, __v_18]; 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
-        let __ret: [G; OUT_556] = [__v_20, __v_21];
-        record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_539] = [__v_20, __v_21];
+        record.function_queries[539].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_556] = [__v_17, __v_18];
-        record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_539] = [__v_17, __v_18];
+        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_557: usize = 5;
-const IN_557: usize = 5;
-const OUT_557: usize = 2;
-fn aiur_fn_557(
-  inp: [G; IN_557],
+const INPUT_SIZE_540: usize = 5;
+const IN_540: usize = 5;
+const OUT_540: usize = 2;
+fn aiur_fn_540(
+  inp: [G; IN_540],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_557], 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];
@@ -48003,31 +46653,31 @@ fn aiur_fn_557(
       1u64 => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_557] = [__v_11, __v_12];
-        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_540] = [__v_11, __v_12];
+        record.function_queries[540].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_558] = { let __args: [G; IN_558] = [__v_2, __v_8, __v_4]; 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_541] = { let __args: [G; IN_541] = [__v_2, __v_8, __v_4]; 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_12: G = __r_arr[0];
             match __v_12.as_canonical_u64() {
               1u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_557] = [__v_13, __v_3];
-                record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_540] = [__v_13, __v_3];
+                record.function_queries[540].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_557] = { let __args: [G; IN_557] = [__v_10, __v_1, __v_2, __v_14, __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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_10, __v_1, __v_2, __v_14, __v_4]; 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_15: G = __r_arr[0];
                 let __v_16: G = __r_arr[1];
-                let __ret: [G; OUT_557] = [__v_15, __v_16];
-                record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_540] = [__v_15, __v_16];
+                record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -48035,11 +46685,11 @@ fn aiur_fn_557(
           _ => {
             let __v_12: G = G::from_u64(1);
             let __v_13: G = (__v_3 + __v_12);
-            let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_10, __v_1, __v_2, __v_13, __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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_10, __v_1, __v_2, __v_13, __v_4]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_14, __v_15];
-            record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_540] = [__v_14, __v_15];
+            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48051,15 +46701,15 @@ fn aiur_fn_557(
   })
 }
 
-const INPUT_SIZE_558: usize = 3;
-const IN_558: usize = 3;
-const OUT_558: usize = 1;
-fn aiur_fn_558(
-  inp: [G; IN_558],
+const INPUT_SIZE_541: usize = 3;
+const IN_541: usize = 3;
+const OUT_541: usize = 1;
+fn aiur_fn_541(
+  inp: [G; IN_541],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_558], 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];
@@ -48071,8 +46721,8 @@ fn aiur_fn_558(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_558] = [__v_6];
-        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_541] = [__v_6];
+        record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -48083,28 +46733,28 @@ fn aiur_fn_558(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_558] = [__v_9];
-            record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_541] = [__v_9];
+            record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_2, __v_9]; 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_386] = { let __args: [G; IN_386] = [__v_4, __v_2, __v_9]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_7, __v_10]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_7, __v_10]; 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_5, __v_2]; 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_541] = { let __args: [G; IN_541] = [__v_8, __v_5, __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_12: G = __r_arr[0];
-                let __ret: [G; OUT_558] = [__v_12];
-                record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_541] = [__v_12];
+                record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_558] = [__v_12];
-                record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_541] = [__v_12];
+                record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -48121,93 +46771,40 @@ fn aiur_fn_558(
   })
 }
 
-const INPUT_SIZE_559: usize = 3;
-const IN_559: usize = 3;
-const OUT_559: usize = 2;
-fn aiur_fn_559(
-  inp: [G; IN_559],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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 __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(0);
-        let __ret: [G; OUT_559] = [__v_6, __v_7];
-        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_6: G = (__v_4 - __v_1);
-        match __v_6.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_559] = [__v_7, __v_2];
-            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_2 + __v_7);
-            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_5, __v_1, __v_8]; 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_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_559] = [__v_9, __v_10];
-            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_560: usize = 1;
-const IN_560: usize = 1;
-const OUT_560: usize = 2;
-fn aiur_fn_560(
-  inp: [G; IN_560],
+const INPUT_SIZE_542: usize = 1;
+const IN_542: usize = 1;
+const OUT_542: usize = 2;
+fn aiur_fn_542(
+  inp: [G; IN_542],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_560], ExecError> {
+) -> Result<[G; OUT_542], 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_561] = { let __args: [G; IN_561] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_0, __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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_4]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_4]; 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 __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_560] = [__v_6, __v_5];
-    record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_542] = [__v_6, __v_5];
+    record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_561: usize = 2;
-const IN_561: usize = 2;
-const OUT_561: usize = 2;
-fn aiur_fn_561(
-  inp: [G; IN_561],
+const INPUT_SIZE_543: usize = 2;
+const IN_543: usize = 2;
+const OUT_543: usize = 2;
+fn aiur_fn_543(
+  inp: [G; IN_543],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_561], 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];
@@ -48220,31 +46817,31 @@ fn aiur_fn_561(
       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_561] = { let __args: [G; IN_561] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_561] = [__v_8, __v_9];
-        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_543] = [__v_8, __v_9];
+        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_561] = [__v_1, __v_0];
-        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_543] = [__v_1, __v_0];
+        record.function_queries[543].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_544: usize = 3;
+const IN_544: usize = 3;
+const OUT_544: usize = 1;
+fn aiur_fn_544(
+  inp: [G; IN_544],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_562], 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];
@@ -48258,19 +46855,19 @@ fn aiur_fn_562(
         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_562] = [__v_8];
-        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_544] = [__v_8];
+        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_400] = { let __args: [G; IN_400] = [__v_4, __v_1, __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_386] = { let __args: [G; IN_386] = [__v_4, __v_1, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __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 __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_5, __v_1, __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_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_562] = [__v_9];
-        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_544] = [__v_9];
+        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48280,15 +46877,15 @@ fn aiur_fn_562(
   })
 }
 
-const INPUT_SIZE_563: usize = 4;
-const IN_563: usize = 4;
-const OUT_563: usize = 1;
-fn aiur_fn_563(
-  inp: [G; IN_563],
+const INPUT_SIZE_545: usize = 4;
+const IN_545: usize = 4;
+const OUT_545: usize = 1;
+fn aiur_fn_545(
+  inp: [G; IN_545],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_563], 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];
@@ -48297,8 +46894,8 @@ fn aiur_fn_563(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_563] = [__v_0];
-        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_545] = [__v_0];
+        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48311,25 +46908,25 @@ fn aiur_fn_563(
         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_563] = { let __args: [G; IN_563] = [__v_11, __v_1, __v_2, __v_13]; 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_11, __v_1, __v_2, __v_13]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_563] = [__v_14];
-        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_545] = [__v_14];
+        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_564: usize = 4;
-const IN_564: usize = 4;
-const OUT_564: usize = 1;
-fn aiur_fn_564(
-  inp: [G; IN_564],
+const INPUT_SIZE_546: usize = 4;
+const IN_546: usize = 4;
+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_564], ExecError> {
+) -> 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];
@@ -48338,8 +46935,8 @@ fn aiur_fn_564(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_564] = [__v_0];
-        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_546] = [__v_0];
+        record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48354,59 +46951,59 @@ fn aiur_fn_564(
         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_564] = { let __args: [G; IN_564] = [__v_13, __v_1, __v_2, __v_15]; 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_13, __v_1, __v_2, __v_15]; 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_16: G = __r_arr[0];
-        let __ret: [G; OUT_564] = [__v_16];
-        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_546] = [__v_16];
+        record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_565: usize = 2;
-const IN_565: usize = 2;
-const OUT_565: usize = 2;
-fn aiur_fn_565(
-  inp: [G; IN_565],
+const INPUT_SIZE_547: usize = 2;
+const IN_547: usize = 2;
+const OUT_547: usize = 2;
+fn aiur_fn_547(
+  inp: [G; IN_547],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_565], ExecError> {
+) -> 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 __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_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __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 __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_4]; 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_5]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_5]; 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 __v_7: G = __r_arr[0];
-    let __ret: [G; OUT_565] = [__v_7, __v_6];
-    record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_547] = [__v_7, __v_6];
+    record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_566: usize = 3;
-const IN_566: usize = 3;
-const OUT_566: usize = 2;
-fn aiur_fn_566(
-  inp: [G; IN_566],
+const INPUT_SIZE_548: usize = 3;
+const IN_548: usize = 3;
+const OUT_548: usize = 2;
+fn aiur_fn_548(
+  inp: [G; IN_548],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_566], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_566] = [__v_2, __v_0];
-        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_548] = [__v_2, __v_0];
+        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48421,11 +47018,11 @@ fn aiur_fn_566(
             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_566] = { let __args: [G; IN_566] = [__v_5, __v_8, __v_10]; 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 __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_5, __v_8, __v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_566] = [__v_11, __v_12];
-            record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_548] = [__v_11, __v_12];
+            record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -48437,15 +47034,15 @@ fn aiur_fn_566(
   })
 }
 
-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_549: usize = 3;
+const IN_549: usize = 3;
+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_567], 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];
@@ -48453,8 +47050,8 @@ fn aiur_fn_567(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_567] = [__v_0];
-        record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_549] = [__v_0];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48467,25 +47064,25 @@ fn aiur_fn_567(
         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_567] = { let __args: [G; IN_567] = [__v_10, __v_1, __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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_10, __v_1, __v_12]; 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_13: G = __r_arr[0];
-        let __ret: [G; OUT_567] = [__v_13];
-        record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_549] = [__v_13];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_568: usize = 15;
-const IN_568: usize = 15;
-const OUT_568: usize = 1;
-fn aiur_fn_568(
-  inp: [G; IN_568],
+const INPUT_SIZE_550: usize = 15;
+const IN_550: usize = 15;
+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_568], 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];
@@ -48511,12 +47108,12 @@ fn aiur_fn_568(
         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_568] = [__v_20];
-        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_550] = [__v_20];
+        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_12, __v_16]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_12, __v_16]; 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 __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];
@@ -48532,16 +47129,16 @@ fn aiur_fn_568(
         let __v_29: G = __loaded[10];
         match __v_19.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__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[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 __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__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[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_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_568] = { let __args: [G; IN_568] = [__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[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 __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__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[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_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_568] = [__v_35];
-            record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_550] = [__v_35];
+            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -48556,15 +47153,15 @@ fn aiur_fn_568(
   })
 }
 
-const INPUT_SIZE_569: usize = 8;
-const IN_569: usize = 8;
-const OUT_569: usize = 1;
-fn aiur_fn_569(
-  inp: [G; IN_569],
+const INPUT_SIZE_551: usize = 8;
+const IN_551: usize = 8;
+const OUT_551: usize = 1;
+fn aiur_fn_551(
+  inp: [G; IN_551],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_569], 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];
@@ -48575,23 +47172,23 @@ fn aiur_fn_569(
     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_570] = { let __args: [G; IN_570] = [__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[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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__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[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_9: G = __r_arr[0];
-    let __ret: [G; OUT_569] = [__v_9];
-    record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_551] = [__v_9];
+    record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_570: usize = 9;
-const IN_570: usize = 9;
-const OUT_570: usize = 1;
-fn aiur_fn_570(
-  inp: [G; IN_570],
+const INPUT_SIZE_552: usize = 9;
+const IN_552: usize = 9;
+const OUT_552: usize = 1;
+fn aiur_fn_552(
+  inp: [G; IN_552],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_570], 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];
@@ -48614,12 +47211,12 @@ fn aiur_fn_570(
         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_570] = [__v_17];
-        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_552] = [__v_17];
+        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_6, __v_10]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_6, __v_10]; 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 __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];
@@ -48635,26 +47232,26 @@ fn aiur_fn_570(
         let __v_26: G = __loaded[10];
         match __v_16.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__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[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_517] = { let __args: [G; IN_517] = [__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[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_27: G = __r_arr[0];
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_27, __v_8, __v_28]; 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_386] = { let __args: [G; IN_386] = [__v_27, __v_8, __v_28]; 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_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_570] = { let __args: [G; IN_570] = [__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[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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__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[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_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_570] = [__v_34];
-            record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_552] = [__v_34];
+            record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__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[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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__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[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_27: G = __r_arr[0];
-            let __ret: [G; OUT_570] = [__v_27];
-            record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_552] = [__v_27];
+            record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48666,15 +47263,15 @@ fn aiur_fn_570(
   })
 }
 
-const INPUT_SIZE_571: usize = 11;
-const IN_571: usize = 11;
-const OUT_571: usize = 1;
-fn aiur_fn_571(
-  inp: [G; IN_571],
+const INPUT_SIZE_553: usize = 11;
+const IN_553: usize = 11;
+const OUT_553: usize = 1;
+fn aiur_fn_553(
+  inp: [G; IN_553],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_571], ExecError> {
+) -> 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];
@@ -48688,23 +47285,23 @@ fn aiur_fn_571(
     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_572] = { let __args: [G; IN_572] = [__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[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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__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[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_12: G = __r_arr[0];
-    let __ret: [G; OUT_571] = [__v_12];
-    record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_553] = [__v_12];
+    record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_572: usize = 13;
-const IN_572: usize = 13;
-const OUT_572: usize = 1;
-fn aiur_fn_572(
-  inp: [G; IN_572],
+const INPUT_SIZE_554: usize = 13;
+const IN_554: usize = 13;
+const OUT_554: usize = 1;
+fn aiur_fn_554(
+  inp: [G; IN_554],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_572], 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];
@@ -48731,12 +47328,12 @@ fn aiur_fn_572(
         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_572] = [__v_21];
-        record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_554] = [__v_21];
+        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_9, __v_14]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_9, __v_14]; 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 __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];
@@ -48752,28 +47349,28 @@ fn aiur_fn_572(
         let __v_30: G = __loaded[10];
         match __v_20.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__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[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 __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__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[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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_31]; 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 __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_572] = { let __args: [G; IN_572] = [__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[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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__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[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_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_31, __v_36]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_31, __v_36]; 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 __v_37: G = __r_arr[0];
-            let __ret: [G; OUT_572] = [__v_37];
-            record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_554] = [__v_37];
+            record.function_queries[554].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_572] = { let __args: [G; IN_572] = [__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[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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__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[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_33: G = __r_arr[0];
-            let __ret: [G; OUT_572] = [__v_33];
-            record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_554] = [__v_33];
+            record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48785,15 +47382,15 @@ fn aiur_fn_572(
   })
 }
 
-const INPUT_SIZE_573: usize = 11;
-const IN_573: usize = 11;
-const OUT_573: usize = 1;
-fn aiur_fn_573(
-  inp: [G; IN_573],
+const INPUT_SIZE_555: usize = 11;
+const IN_555: usize = 11;
+const OUT_555: usize = 1;
+fn aiur_fn_555(
+  inp: [G; IN_555],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_573], 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];
@@ -48810,9 +47407,9 @@ fn aiur_fn_573(
     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_508] = { let __args: [G; IN_508] = [__v_1, __v_11, __v_14, __v_9, __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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_11, __v_14, __v_9, __v_10]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_15, __v_2, __v_9, __v_10]; 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_512] = { let __args: [G; IN_512] = [__v_15, __v_2, __v_9, __v_10]; 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_16: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_16.as_canonical_u64() {
   1u64 => {
@@ -48834,40 +47431,40 @@ fn aiur_fn_573(
 }
  };
     let __v_17: G = __mc_out___mc_0[0];
-    let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_7, __v_9]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_7, __v_9]; 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_18, __v_16, __v_9, __v_10]; 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 __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_18, __v_16, __v_9, __v_10]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_19]; 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 __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_19]; 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_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_19]; 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_767] = { let __args: [G; IN_767] = [__v_19]; 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 __v_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_19, __v_8]; 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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_19, __v_8]; 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_22: G = __r_arr[0];
     let __v_23: G = __r_arr[1];
     let __v_24: G = __r_arr[2];
     let __v_25: G = __r_arr[3];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_25]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1, __v_25]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_26, __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 __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_26, __v_3]; 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 = __r_arr[1];
-    let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_19, __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 __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_19, __v_9]; 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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__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[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 __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__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[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_30: G = __r_arr[0];
     let __v_31: G = G::from_u64(0);
-    let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_19, __v_20, __v_29, __v_3, __v_21, __v_5, __v_16, __v_3, __v_9, __v_10, __v_31]; 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 __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_19, __v_20, __v_29, __v_3, __v_21, __v_5, __v_16, __v_3, __v_9, __v_10, __v_31]; 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_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_32]; 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 __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_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_28, __v_4, __v_9, __v_10]; 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_526] = { let __args: [G; IN_526] = [__v_28, __v_4, __v_9, __v_10]; 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 __v_34: G = __r_arr[0];
     let __v_35: G = (__v_21 + __v_33);
     let __v_36: G = G::from_u64(0);
-    let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_34, __v_35, __v_36]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_34, __v_35, __v_36]; 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_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_19, __v_8]; 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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_19, __v_8]; 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -48882,10 +47479,10 @@ fn aiur_fn_573(
     let __v_49: G = (__v_47 - __v_48);
     let __v_50: G = (__v_33 + __v_4);
     let __v_51: G = (__v_21 + __v_50);
-    let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_44, __v_3, __v_49, __v_51, __v_39, __v_40]; 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 __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_44, __v_3, __v_49, __v_51, __v_39, __v_40]; 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_52: G = __r_arr[0];
     let __v_53: G = G::from_u64(0);
-    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_52, __v_4, __v_53]; 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 __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_52, __v_4, __v_53]; 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_54: G = __r_arr[0];
     let __v_55: G = G::from_u64(1);
     let __v_56: G = (__v_47 + __v_55);
@@ -48897,7 +47494,7 @@ fn aiur_fn_573(
     let __v_62: G = G::from_u64(0);
     let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __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 __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_63, __v_4, __v_64]; 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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_63, __v_4, __v_64]; 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_65: G = __r_arr[0];
     let __v_66: G = G::from_u64(3);
     let __v_67: G = G::from_u64(0);
@@ -48909,29 +47506,29 @@ fn aiur_fn_573(
     let __v_73: G = G::from_u64(5);
     let __v_74: G = G::from_u64(0);
     let __v_75: G = { let __values: [G; 4] = [__v_73, __v_54, __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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_75, __v_37]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_75, __v_37]; 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_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_76, __v_32]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_76, __v_32]; 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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_77, __v_30]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_77, __v_30]; 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_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_78, __v_27]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_78, __v_27]; 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_79: G = __r_arr[0];
-    let __ret: [G; OUT_573] = [__v_79];
-    record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_555] = [__v_79];
+    record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_574: usize = 22;
-const IN_574: usize = 22;
-const OUT_574: usize = 1;
-fn aiur_fn_574(
-  inp: [G; IN_574],
+const INPUT_SIZE_556: usize = 22;
+const IN_556: usize = 22;
+const OUT_556: usize = 1;
+fn aiur_fn_556(
+  inp: [G; IN_556],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_574], 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];
@@ -48957,13 +47554,13 @@ fn aiur_fn_574(
     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_575] = { let __args: [G; IN_575] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_19]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_3, __v_19]; 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_2, __v_20]; 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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_20]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_25, __v_26, __v_17, __v_18]; 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_522] = { let __args: [G; IN_522] = [__v_25, __v_26, __v_17, __v_18]; 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_27: G = __r_arr[0];
     let __v_28: G = G::from_u64(1);
     let __v_29: G = G::from_u64(1);
@@ -48979,14 +47576,14 @@ fn aiur_fn_574(
     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_549] = { let __args: [G; IN_549] = [__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[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 __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__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[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_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_200] = { let __args: [G; IN_200] = [__v_42]; 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 __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_200] = { let __args: [G; IN_200] = [__v_43]; 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 __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);
@@ -49000,41 +47597,41 @@ fn aiur_fn_574(
     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_564] = { let __args: [G; IN_564] = [__v_58, __v_46, __v_46, __v_59]; 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_58, __v_46, __v_46, __v_59]; 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_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_577] = { let __args: [G; IN_577] = [__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[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 __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__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[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_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_584] = { let __args: [G; IN_584] = [__v_42, __v_66, __v_67]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_42, __v_66, __v_67]; 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_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_65, __v_68]; 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_65, __v_68]; 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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_69, __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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_69, __v_11]; 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_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_70, __v_10]; 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_70, __v_10]; 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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_71, __v_12]; 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_71, __v_12]; 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_72: G = __r_arr[0];
-    let __ret: [G; OUT_574] = [__v_72];
-    record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_556] = [__v_72];
+    record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_575: usize = 2;
-const IN_575: usize = 2;
-const OUT_575: usize = 1;
-fn aiur_fn_575(
-  inp: [G; IN_575],
+const INPUT_SIZE_557: usize = 2;
+const IN_557: usize = 2;
+const OUT_557: usize = 1;
+fn aiur_fn_557(
+  inp: [G; IN_557],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_575], 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];
@@ -49044,8 +47641,8 @@ fn aiur_fn_575(
         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_575] = [__v_5];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_557] = [__v_5];
+        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49055,26 +47652,26 @@ fn aiur_fn_575(
         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_575] = { let __args: [G; IN_575] = [__v_0, __v_8]; 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 __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_8]; 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_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_575] = [__v_10];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_557] = [__v_10];
+        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_576: usize = 2;
-const IN_576: usize = 2;
-const OUT_576: usize = 1;
-fn aiur_fn_576(
-  inp: [G; IN_576],
+const INPUT_SIZE_558: usize = 2;
+const IN_558: usize = 2;
+const OUT_558: usize = 1;
+fn aiur_fn_558(
+  inp: [G; IN_558],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_576], 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];
@@ -49084,18 +47681,18 @@ fn aiur_fn_576(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_576] = [__v_0];
-        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_558] = [__v_0];
+        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(4);
-        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_4]; 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_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_576] = [__v_8];
-        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_558] = [__v_8];
+        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49105,15 +47702,15 @@ fn aiur_fn_576(
   })
 }
 
-const INPUT_SIZE_577: usize = 15;
-const IN_577: usize = 15;
-const OUT_577: usize = 1;
-fn aiur_fn_577(
-  inp: [G; IN_577],
+const INPUT_SIZE_559: usize = 15;
+const IN_559: usize = 15;
+const OUT_559: usize = 1;
+fn aiur_fn_559(
+  inp: [G; IN_559],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_577], 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];
@@ -49136,41 +47733,41 @@ fn aiur_fn_577(
     let __v_17: G = __loaded[2];
     match __v_15.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_577] = [__v_0];
-        record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_559] = [__v_0];
+        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_14]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_14]; 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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_4, __v_18]; 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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_18]; 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 __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_781] = { let __args: [G; IN_781] = [__v_3, __v_16]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_16]; 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 __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_400] = { let __args: [G; IN_400] = [__v_24, __v_25, __v_26]; 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_386] = { let __args: [G; IN_386] = [__v_24, __v_25, __v_26]; 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_27: G = __r_arr[0];
         let __v_28: G = (__v_7 + __v_8);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_27, __v_28, __v_9]; 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_386] = { let __args: [G; IN_386] = [__v_27, __v_28, __v_9]; 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_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_29, __v_11, __v_12, __v_13]; 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_414] = { let __args: [G; IN_414] = [__v_29, __v_11, __v_12, __v_13]; 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_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_30]; 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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_31]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_31]; 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 __v_33: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_33, __v_11]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_33, __v_11]; 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 __v_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_32, __v_34, __v_12, __v_13]; 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_414] = { let __args: [G; IN_414] = [__v_32, __v_34, __v_12, __v_13]; 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_35: G = __r_arr[0];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_31]; 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 __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);
@@ -49179,27 +47776,27 @@ fn aiur_fn_577(
         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_563] = { let __args: [G; IN_563] = [__v_40, __v_6, __v_42, __v_43]; 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_40, __v_6, __v_42, __v_43]; 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_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_563] = { let __args: [G; IN_563] = [__v_44, __v_7, __v_47, __v_48]; 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_44, __v_7, __v_47, __v_48]; 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_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_563] = { let __args: [G; IN_563] = [__v_49, __v_8, __v_53, __v_54]; 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_49, __v_8, __v_53, __v_54]; 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_35]; 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 __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_799] = { let __args: [G; IN_799] = [__v_57, __v_20]; 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_769] = { let __args: [G; IN_769] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
         let __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_55, __v_58]; 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_400] = { let __args: [G; IN_400] = [__v_55, __v_58]; 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_59: G = __r_arr[0];
         let __v_60: G = G::from_u64(1);
         let __v_61: G = (__v_9 - __v_60);
@@ -49209,22 +47806,22 @@ fn aiur_fn_577(
         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_544] = { let __args: [G; IN_544] = [__v_66, __v_36, __v_67]; 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 __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_66, __v_36, __v_67]; 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_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_576] = { let __args: [G; IN_576] = [__v_71, __v_31]; 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_71, __v_31]; 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_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_577] = { let __args: [G; IN_577] = [__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[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 __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__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[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_78: G = __r_arr[0];
-        let __ret: [G; OUT_577] = [__v_78];
-        record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_559] = [__v_78];
+        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49234,15 +47831,15 @@ fn aiur_fn_577(
   })
 }
 
-const INPUT_SIZE_578: usize = 7;
-const IN_578: usize = 7;
-const OUT_578: usize = 1;
-fn aiur_fn_578(
-  inp: [G; IN_578],
+const INPUT_SIZE_560: usize = 7;
+const IN_560: usize = 7;
+const OUT_560: usize = 1;
+fn aiur_fn_560(
+  inp: [G; IN_560],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_578], 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];
@@ -49254,7 +47851,7 @@ fn aiur_fn_578(
     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_505] = { let __args: [G; IN_505] = [__v_1, __v_9]; 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 __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_9]; 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_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];
@@ -49263,7 +47860,7 @@ fn aiur_fn_578(
     let __v_14: G = __loaded[3];
     match __v_11.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_12]; 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 __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 };
@@ -49273,8 +47870,8 @@ fn aiur_fn_578(
         let __v_20: G = __loaded[3];
         match __v_17.as_canonical_u64() {
           2u64 => {
-            let __ret: [G; OUT_578] = [__v_18];
-            record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_560] = [__v_18];
+            record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49289,15 +47886,15 @@ fn aiur_fn_578(
   })
 }
 
-const INPUT_SIZE_579: usize = 6;
-const IN_579: usize = 6;
-const OUT_579: usize = 1;
-fn aiur_fn_579(
-  inp: [G; IN_579],
+const INPUT_SIZE_561: usize = 6;
+const IN_561: usize = 6;
+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_579], 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];
@@ -49308,7 +47905,7 @@ fn aiur_fn_579(
     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_513] = { let __args: [G; IN_513] = [__v_0, __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 __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_0, __v_8]; 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_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];
@@ -49317,40 +47914,40 @@ fn aiur_fn_579(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11]; 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 __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_795] = { let __args: [G; IN_795] = [__v_15, __v_5]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_15, __v_5]; 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 __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_636] = { let __args: [G; IN_636] = [__v_16, __v_18]; 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 __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_16, __v_18]; 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_19: G = __r_arr[0];
-        let __ret: [G; OUT_579] = [__v_19];
-        record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_561] = [__v_19];
+        record.function_queries[561].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_579] = [__v_16];
-        record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_561] = [__v_16];
+        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_580: usize = 6;
-const IN_580: usize = 6;
-const OUT_580: usize = 1;
-fn aiur_fn_580(
-  inp: [G; IN_580],
+const INPUT_SIZE_562: usize = 6;
+const IN_562: usize = 6;
+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_580], 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];
@@ -49360,36 +47957,36 @@ fn aiur_fn_580(
     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_581] = { let __args: [G; IN_581] = [__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[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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__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[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];
     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_581] = { let __args: [G; IN_581] = [__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[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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__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[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_11: G = __r_arr[0];
-        let __ret: [G; OUT_580] = [__v_11];
-        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_562] = [__v_11];
+        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_580] = [__v_8];
-        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_562] = [__v_8];
+        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_581: usize = 9;
-const IN_581: usize = 9;
-const OUT_581: usize = 1;
-fn aiur_fn_581(
-  inp: [G; IN_581],
+const INPUT_SIZE_563: usize = 9;
+const IN_563: usize = 9;
+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_581], ExecError> {
+) -> 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];
@@ -49407,8 +48004,8 @@ fn aiur_fn_581(
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_581] = [__v_12];
-        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_563] = [__v_12];
+        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -49426,7 +48023,7 @@ fn aiur_fn_581(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_19, __v_14, __v_15, __v_17, __v_18, __v_16, __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 __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_19, __v_14, __v_15, __v_17, __v_18, __v_16, __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 __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));
@@ -49436,7 +48033,7 @@ fn aiur_fn_581(
     break '__mc_0 [__v_26];
   },
   _ => {
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_22, __v_4]; 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 __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];
   },
@@ -49452,9 +48049,9 @@ fn aiur_fn_581(
     break '__mc_1 [__v_28];
   },
   _ => {
-    let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_14, __v_15, __v_17, __v_18, __v_16, __v_3]; 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 __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_14, __v_15, __v_17, __v_18, __v_16, __v_3]; 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_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_28, __v_2]; 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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_28, __v_2]; 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_29: G = __r_arr[0];
     break '__mc_1 [__v_29];
   },
@@ -49463,17 +48060,17 @@ fn aiur_fn_581(
                 let __v_28: G = __mc_out___mc_1[0];
                 match __v_28.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_581] = [__v_8];
-                    record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_563] = [__v_8];
+                    record.function_queries[563].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_581] = { let __args: [G; IN_581] = [__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[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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__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[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_31: G = __r_arr[0];
-                    let __ret: [G; OUT_581] = [__v_31];
-                    record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_563] = [__v_31];
+                    record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -49484,10 +48081,10 @@ fn aiur_fn_581(
               0u64 => {
                 let __v_28: G = G::from_u64(1);
                 let __v_29: G = (__v_8 + __v_28);
-                let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__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[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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__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[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_30: G = __r_arr[0];
-                let __ret: [G; OUT_581] = [__v_30];
-                record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_563] = [__v_30];
+                record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -49498,10 +48095,10 @@ fn aiur_fn_581(
           _ => {
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__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[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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__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[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_581] = [__v_25];
-            record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_563] = [__v_25];
+            record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49513,15 +48110,15 @@ fn aiur_fn_581(
   })
 }
 
-const INPUT_SIZE_582: usize = 3;
-const IN_582: usize = 3;
-const OUT_582: usize = 1;
-fn aiur_fn_582(
-  inp: [G; IN_582],
+const INPUT_SIZE_564: usize = 3;
+const IN_564: usize = 3;
+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_582], 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];
@@ -49538,12 +48135,12 @@ fn aiur_fn_582(
         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_582] = [__v_11];
-        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_564] = [__v_11];
+        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_4]; 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 __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];
@@ -49569,13 +48166,13 @@ fn aiur_fn_582(
  };
         let __v_21: G = __mc_out___mc_0[0];
         let __v_22: G = G::from_u64(0);
-        let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_5, __v_6, __v_21, __v_1, __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 __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_4, __v_5, __v_6, __v_21, __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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_8, __v_1, __v_2]; 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_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_582] = [__v_25];
-        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_564] = [__v_25];
+        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49585,71 +48182,15 @@ fn aiur_fn_582(
   })
 }
 
-const INPUT_SIZE_583: usize = 2;
-const IN_583: usize = 2;
-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_583], 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 __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() {
-      0u64 => {
-        match __v_3.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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_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 __ret: [G; OUT_583] = [__v_11];
-                record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_584: usize = 3;
-const IN_584: usize = 3;
-const OUT_584: usize = 1;
-fn aiur_fn_584(
-  inp: [G; IN_584],
+const INPUT_SIZE_565: usize = 3;
+const IN_565: usize = 3;
+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_584], 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];
@@ -49663,21 +48204,21 @@ fn aiur_fn_584(
         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_584] = [__v_8];
-        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_565] = [__v_8];
+        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_1, __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_386] = { let __args: [G; IN_386] = [__v_4, __v_1, __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_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_584] = { let __args: [G; IN_584] = [__v_5, __v_1, __v_9]; 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 __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_9]; 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 __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_584] = [__v_11];
-        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_565] = [__v_11];
+        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49687,15 +48228,15 @@ fn aiur_fn_584(
   })
 }
 
-const INPUT_SIZE_585: usize = 4;
-const IN_585: usize = 4;
-const OUT_585: usize = 0;
-fn aiur_fn_585(
-  inp: [G; IN_585],
+const INPUT_SIZE_566: usize = 4;
+const IN_566: usize = 4;
+const OUT_566: usize = 0;
+fn aiur_fn_566(
+  inp: [G; IN_566],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_585], 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];
@@ -49717,8 +48258,8 @@ fn aiur_fn_585(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_585] = [];
-            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_566] = [];
+            record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49742,7 +48283,7 @@ fn aiur_fn_585(
                     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_470] = { let __args: [G; IN_470] = [__v_7, __v_12, __v_16, __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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_12, __v_16, __v_2, __v_3]; 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_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() });
@@ -49754,9 +48295,9 @@ fn aiur_fn_585(
                     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_585] = { let __args: [G; IN_585] = [__v_8, __v_13, __v_2, __v_3]; 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 __ret: [G; OUT_585] = [];
-                    record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_8, __v_13, __v_2, __v_3]; 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 __ret: [G; OUT_566] = [];
+                    record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -49775,15 +48316,15 @@ fn aiur_fn_585(
   })
 }
 
-const INPUT_SIZE_586: usize = 13;
-const IN_586: usize = 13;
-const OUT_586: usize = 0;
-fn aiur_fn_586(
-  inp: [G; IN_586],
+const INPUT_SIZE_567: usize = 13;
+const IN_567: usize = 13;
+const OUT_567: usize = 0;
+fn aiur_fn_567(
+  inp: [G; IN_567],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_586], 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];
@@ -49800,7 +48341,7 @@ fn aiur_fn_586(
     let __v_12: G = inp[12];
     match __v_1.as_canonical_u64() {
       6u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_12, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_12, __v_4]; 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 __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];
@@ -49816,13 +48357,13 @@ fn aiur_fn_586(
         let __v_24: G = __loaded[10];
         match __v_14.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_19, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_19, __v_5]; 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 __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_586] = [];
-            record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_567] = [];
+            record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49837,20 +48378,20 @@ fn aiur_fn_586(
   })
 }
 
-const INPUT_SIZE_587: usize = 3;
-const IN_587: usize = 3;
-const OUT_587: usize = 1;
-fn aiur_fn_587(
-  inp: [G; IN_587],
+const INPUT_SIZE_568: usize = 3;
+const IN_568: usize = 3;
+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_587], ExecError> {
+) -> Result<[G; OUT_568], ExecError> {
   stacker::maybe_grow(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_781] = { let __args: [G; IN_781] = [__v_1, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_0]; 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 __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];
@@ -49866,9 +48407,9 @@ fn aiur_fn_587(
     let __v_14: G = __loaded[10];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_15]; 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 __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);
@@ -49878,31 +48419,31 @@ fn aiur_fn_587(
             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_508] = { let __args: [G; IN_508] = [__v_6, __v_19, __v_22, __v_1, __v_2]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_6, __v_19, __v_22, __v_1, __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_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_229] = { let __args: [G; IN_229] = [__v_23, __v_26]; 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 __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_587] = [__v_28];
-                record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_568] = [__v_28];
+                record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; 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 __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_781] = { let __args: [G; IN_781] = [__v_9, __v_31]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_9, __v_31]; 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 __v_32: G = __r_arr[0];
-                    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_32]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_32]; 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 __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];
@@ -49919,22 +48460,22 @@ fn aiur_fn_587(
                     match __v_34.as_canonical_u64() {
                       6u64 => {
                         let __v_45: G = G::from_bool((__v_40 == G::ZERO));
-                        let __ret: [G; OUT_587] = [__v_45];
-                        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_568] = [__v_45];
+                        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_45: G = G::from_u64(0);
-                        let __ret: [G; OUT_587] = [__v_45];
-                        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_568] = [__v_45];
+                        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_31: G = G::from_u64(0);
-                    let __ret: [G; OUT_587] = [__v_31];
-                    record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_568] = [__v_31];
+                    record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -49946,31 +48487,31 @@ fn aiur_fn_587(
           },
           _ => {
             let __v_19: G = G::from_u64(0);
-            let __ret: [G; OUT_587] = [__v_19];
-            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_568] = [__v_19];
+            record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_587] = [__v_15];
-        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_568] = [__v_15];
+        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_588: usize = 2;
-const IN_588: usize = 2;
-const OUT_588: usize = 1;
-fn aiur_fn_588(
-  inp: [G; IN_588],
+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_588], 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];
@@ -49994,22 +48535,22 @@ fn aiur_fn_588(
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_588] = [__v_13];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_13];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_588] = [__v_13];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_13];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_588] = [__v_10];
-            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_569] = [__v_10];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50023,14 +48564,14 @@ fn aiur_fn_588(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_588] = [__v_10];
-            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_569] = [__v_10];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_588] = [__v_10];
-            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_569] = [__v_10];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50049,22 +48590,22 @@ fn aiur_fn_588(
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_588] = [__v_13];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_13];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_588] = [__v_13];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_13];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_588] = [__v_10];
-            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_569] = [__v_10];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50077,28 +48618,28 @@ fn aiur_fn_588(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_3, __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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __v_8]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_8]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_588] = [__v_11];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_11];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_588] = [__v_11];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_11];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_588] = [__v_10];
-            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_569] = [__v_10];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50111,28 +48652,28 @@ fn aiur_fn_588(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_3, __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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __v_8]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_8]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_588] = [__v_11];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_11];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_588] = [__v_11];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_11];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_588] = [__v_10];
-            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_569] = [__v_10];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50145,51 +48686,51 @@ fn aiur_fn_588(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_3, __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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __v_8]; 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 __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_8]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_588] = [__v_11];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_11];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_588] = [__v_11];
-                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_569] = [__v_11];
+                record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_588] = [__v_10];
-            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_569] = [__v_10];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_588] = [__v_6];
-        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_569] = [__v_6];
+        record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_589: usize = 8;
-const IN_589: usize = 8;
-const OUT_589: usize = 1;
-fn aiur_fn_589(
-  inp: [G; IN_589],
+const INPUT_SIZE_570: usize = 8;
+const IN_570: usize = 8;
+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_589], 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];
@@ -50199,7 +48740,7 @@ fn aiur_fn_589(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_7, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_7, __v_5]; 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 __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];
@@ -50215,35 +48756,35 @@ fn aiur_fn_589(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_12]; 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 __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_12]; 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_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_590] = { let __args: [G; IN_590] = [__v_6, __v_5, __v_20, __v_21, __v_22]; 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 __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_5, __v_20, __v_21, __v_22]; 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_23: G = __r_arr[0];
-        let __ret: [G; OUT_589] = [__v_23];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_570] = [__v_23];
+        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_20: G = G::from_u64(0);
-        let __ret: [G; OUT_589] = [__v_20];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_570] = [__v_20];
+        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_590: usize = 5;
-const IN_590: usize = 5;
-const OUT_590: usize = 1;
-fn aiur_fn_590(
-  inp: [G; IN_590],
+const INPUT_SIZE_571: usize = 5;
+const IN_571: usize = 5;
+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_590], 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];
@@ -50262,15 +48803,15 @@ fn aiur_fn_590(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_590] = [__v_11];
-            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_571] = [__v_11];
+            record.function_queries[571].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_590] = [__v_12];
-            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_571] = [__v_12];
+            record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50295,26 +48836,26 @@ fn aiur_fn_590(
             let __v_14: G = __mc_out___mc_0[0];
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_590] = [__v_3];
-                record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_571] = [__v_3];
+                record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_8, __v_2]; 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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_8, __v_2]; 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_15: G = __r_arr[0];
                 match __v_15.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_590] = [__v_3];
-                    record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_571] = [__v_3];
+                    record.function_queries[571].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_590] = { let __args: [G; IN_590] = [__v_10, __v_1, __v_2, __v_17, __v_14]; 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 __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10, __v_1, __v_2, __v_17, __v_14]; 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_18: G = __r_arr[0];
-                    let __ret: [G; OUT_590] = [__v_18];
-                    record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_571] = [__v_18];
+                    record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -50327,10 +48868,10 @@ fn aiur_fn_590(
           _ => {
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_10, __v_1, __v_2, __v_15, __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 __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10, __v_1, __v_2, __v_15, __v_4]; 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_16: G = __r_arr[0];
-            let __ret: [G; OUT_590] = [__v_16];
-            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_571] = [__v_16];
+            record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50342,15 +48883,15 @@ fn aiur_fn_590(
   })
 }
 
-const INPUT_SIZE_591: usize = 14;
-const IN_591: usize = 14;
-const OUT_591: usize = 0;
-fn aiur_fn_591(
-  inp: [G; IN_591],
+const INPUT_SIZE_572: usize = 14;
+const IN_572: usize = 14;
+const OUT_572: usize = 0;
+fn aiur_fn_572(
+  inp: [G; IN_572],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_591], 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];
@@ -50368,14 +48909,14 @@ fn aiur_fn_591(
     let __v_13: G = inp[13];
     match __v_1.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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 __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_14, __v_12, __v_13]; 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 __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_14, __v_11, __v_12]; 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 __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_12, __v_13]; 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 __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_14, __v_11, __v_12]; 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];
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_14, __v_12, __v_13]; 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 __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_14, __v_12, __v_13]; 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_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_12, __v_15]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_12, __v_15]; 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 __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];
@@ -50389,7 +48930,7 @@ fn aiur_fn_591(
         let __v_26: G = __loaded[8];
         let __v_27: G = __loaded[9];
         let __v_28: G = __loaded[10];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_12, __v_14]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_12, __v_14]; 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 __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];
@@ -50414,9 +48955,9 @@ fn aiur_fn_591(
                 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_508] = { let __args: [G; IN_508] = [__v_32, __v_41, __v_44, __v_12, __v_13]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_32, __v_41, __v_44, __v_12, __v_13]; 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_45: G = __r_arr[0];
-                let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_45, __v_35, __v_12, __v_13]; 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_512] = { let __args: [G; IN_512] = [__v_45, __v_35, __v_12, __v_13]; 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_46: G = __r_arr[0];
                 let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_46.as_canonical_u64() {
   1u64 => {
@@ -50438,59 +48979,59 @@ fn aiur_fn_591(
 }
  };
                 let __v_47: G = __mc_out___mc_0[0];
-                let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_15, __v_12]; 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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_15, __v_12]; 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_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_48, __v_46, __v_12, __v_13]; 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 __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_48, __v_46, __v_12, __v_13]; 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__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[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 __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__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[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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__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[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 __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__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[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_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_470] = { let __args: [G; IN_470] = [__v_3, __v_51, __v_54, __v_12, __v_13]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_3, __v_51, __v_54, __v_12, __v_13]; 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_55: G = __r_arr[0];
-                let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_49]; 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 __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_49]; 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_56: G = __r_arr[0];
-                let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_49]; 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_767] = { let __args: [G; IN_767] = [__v_49]; 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 __v_57: G = __r_arr[0];
-                let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_49, __v_12]; 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 __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_49, __v_12]; 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_58: G = __r_arr[0];
-                let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__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[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 __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__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[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_59: G = __r_arr[0];
                 let __v_60: G = G::from_u64(0);
-                let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__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[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 __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__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[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_61: G = __r_arr[0];
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_61]; 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 __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_630] = { let __args: [G; IN_630] = [__v_56, __v_50, __v_12, __v_63]; 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 __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_56, __v_50, __v_12, __v_63]; 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_64: G = __r_arr[0];
                 let __v_65: G = G::from_u64(0);
-                let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_46, __v_19, __v_65]; 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 __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_46, __v_19, __v_65]; 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_66: G = __r_arr[0];
-                let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_20, __v_66]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_20, __v_66]; 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_67: G = __r_arr[0];
-                let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_67, __v_21]; 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 __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_67, __v_21]; 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_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_582] = { let __args: [G; IN_582] = [__v_49, __v_11, __v_12]; 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 __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_49, __v_11, __v_12]; 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_71: G = __r_arr[0];
-                let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_49, __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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_49, __v_50]; 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_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_639] = { let __args: [G; IN_639] = [__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[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 __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__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[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_76: G = __r_arr[0];
-                let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_8, __v_76, __v_12, __v_13]; 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 __ret: [G; OUT_591] = [];
-                record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_8, __v_76, __v_12, __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 __ret: [G; OUT_572] = [];
+                record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -50510,43 +49051,43 @@ fn aiur_fn_591(
   })
 }
 
-const INPUT_SIZE_592: usize = 4;
-const IN_592: usize = 4;
-const OUT_592: usize = 1;
-fn aiur_fn_592(
-  inp: [G; IN_592],
+const INPUT_SIZE_573: usize = 4;
+const IN_573: usize = 4;
+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_592], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1, __v_2]; 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 __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_1, __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_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_4, __v_5, __v_0, __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 __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_5, __v_0, __v_2, __v_3]; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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_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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_6]; 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 __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_592] = [__v_6];
-        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_573] = [__v_6];
+        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_6, __v_7, __v_2, __v_3]; 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 __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_6, __v_7, __v_2, __v_3]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_592] = [__v_12];
-        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_573] = [__v_12];
+        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -50556,61 +49097,61 @@ fn aiur_fn_592(
   })
 }
 
-const INPUT_SIZE_593: usize = 5;
-const IN_593: usize = 5;
-const OUT_593: usize = 1;
-fn aiur_fn_593(
-  inp: [G; IN_593],
+const INPUT_SIZE_574: usize = 5;
+const IN_574: usize = 5;
+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_593], 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];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_0]; 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_767] = { let __args: [G; IN_767] = [__v_0]; 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 __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_593] = [__v_0];
-        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_574] = [__v_0];
+        record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_1]; 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 __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_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_594] = { let __args: [G; IN_594] = [__v_7, __v_8, __v_9, __v_10, __v_2, __v_3, __v_4]; 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_575] = { let __args: [G; IN_575] = [__v_7, __v_8, __v_9, __v_10, __v_2, __v_3, __v_4]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_11]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_11]; 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_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_593] = { let __args: [G; IN_593] = [__v_12, __v_14, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_12, __v_14, __v_2, __v_3, __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_15: G = __r_arr[0];
-        let __ret: [G; OUT_593] = [__v_15];
-        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_574] = [__v_15];
+        record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_594: usize = 7;
-const IN_594: usize = 7;
-const OUT_594: usize = 1;
-fn aiur_fn_594(
-  inp: [G; IN_594],
+const INPUT_SIZE_575: usize = 7;
+const IN_575: usize = 7;
+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_594], ExecError> {
+) -> Result<[G; OUT_575], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50619,7 +49160,7 @@ fn aiur_fn_594(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_5, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_5, __v_0]; 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 __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];
@@ -50635,33 +49176,33 @@ fn aiur_fn_594(
     let __v_18: G = __loaded[10];
     match __v_8.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__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[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 __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__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[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_19: G = __r_arr[0];
-        let __ret: [G; OUT_594] = [__v_19];
-        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_575] = [__v_19];
+        record.function_queries[575].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_594] = [__v_21];
-        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_575] = [__v_21];
+        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_595: usize = 8;
-const IN_595: usize = 8;
-const OUT_595: usize = 1;
-fn aiur_fn_595(
-  inp: [G; IN_595],
+const INPUT_SIZE_576: usize = 8;
+const IN_576: usize = 8;
+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_595], 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];
@@ -50680,12 +49221,12 @@ fn aiur_fn_595(
         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_595] = [__v_13];
-        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_576] = [__v_13];
+        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_6, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_6, __v_9]; 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 __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];
@@ -50703,12 +49244,12 @@ fn aiur_fn_595(
           6u64 => {
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_14, __v_1]; 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 __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_14, __v_1]; 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_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
   _ => {
-    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_14, __v_1, __v_3, __v_4, __v_6, __v_7]; 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 __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_14, __v_1, __v_3, __v_4, __v_6, __v_7]; 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_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
@@ -50716,21 +49257,21 @@ fn aiur_fn_595(
  };
             let __v_23: G = __mc_out___mc_0[0];
             let __v_24: G = G::from_u64(0);
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_23, __v_5, __v_6, __v_24]; 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 __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_23, __v_5, __v_6, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__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[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 __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__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[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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_25, __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 __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_25, __v_26]; 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 __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_595] = [__v_27];
-            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_576] = [__v_27];
+            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__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[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 __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__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[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_23: G = __r_arr[0];
-            let __ret: [G; OUT_595] = [__v_23];
-            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_576] = [__v_23];
+            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50742,15 +49283,15 @@ fn aiur_fn_595(
   })
 }
 
-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_577: usize = 2;
+const IN_577: usize = 2;
+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_596], 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];
@@ -50762,19 +49303,19 @@ fn aiur_fn_596(
     let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_596] = [__v_0];
-        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_577] = [__v_0];
+        record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_3, __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 __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_0, __v_3, __v_4]; 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_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_6]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_6]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_596] = [__v_8];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_8];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -50784,12 +49325,12 @@ fn aiur_fn_596(
             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_786] = { let __args: [G; IN_786] = [__v_0, __v_13]; 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_756] = { let __args: [G; IN_756] = [__v_0, __v_13]; 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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_14, __v_6]; 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 __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_14, __v_6]; 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_15: G = __r_arr[0];
-            let __ret: [G; OUT_596] = [__v_15];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_577] = [__v_15];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50801,15 +49342,15 @@ fn aiur_fn_596(
   })
 }
 
-const INPUT_SIZE_597: usize = 3;
-const IN_597: usize = 3;
-const OUT_597: usize = 1;
-fn aiur_fn_597(
-  inp: [G; IN_597],
+const INPUT_SIZE_578: usize = 3;
+const IN_578: usize = 3;
+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_597], 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];
@@ -50824,8 +49365,8 @@ fn aiur_fn_597(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_597] = [__v_9];
-        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_578] = [__v_9];
+        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -50837,25 +49378,25 @@ fn aiur_fn_597(
             match __v_5.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(1);
-                let __ret: [G; OUT_597] = [__v_12];
-                record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_598] = { let __args: [G; IN_598] = [__v_6, __v_2]; 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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_2]; 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];
                 match __v_12.as_canonical_u64() {
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
-                    let __ret: [G; OUT_597] = [__v_13];
-                    record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_578] = [__v_13];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_8, __v_1, __v_2]; 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_597] = [__v_13];
-                    record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_578] = [__v_13];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -50866,10 +49407,10 @@ fn aiur_fn_597(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_8, __v_1, __v_2]; 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 __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_8, __v_1, __v_2]; 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_597] = [__v_12];
-            record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_578] = [__v_12];
+            record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50881,15 +49422,15 @@ fn aiur_fn_597(
   })
 }
 
-const INPUT_SIZE_598: usize = 2;
-const IN_598: usize = 2;
-const OUT_598: usize = 1;
-fn aiur_fn_598(
-  inp: [G; IN_598],
+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_598], 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];
@@ -50906,14 +49447,14 @@ fn aiur_fn_598(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_598] = [__v_8];
-            record.function_queries[598].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);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_598] = [__v_8];
-            record.function_queries[598].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);
           },
           _ => {
@@ -50929,24 +49470,24 @@ fn aiur_fn_598(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_598] = [__v_8];
-            record.function_queries[598].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);
           },
           0u64 => {
             let __v_8: G = (__v_3 - __v_6);
             match __v_8.as_canonical_u64() {
               0u64 => {
-                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 __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_598] = [__v_9];
-                record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_598] = [__v_9];
-                record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_579] = [__v_9];
+                record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -50963,15 +49504,15 @@ fn aiur_fn_598(
   })
 }
 
-const INPUT_SIZE_599: usize = 3;
-const IN_599: usize = 3;
-const OUT_599: usize = 1;
-fn aiur_fn_599(
-  inp: [G; IN_599],
+const INPUT_SIZE_580: usize = 3;
+const IN_580: usize = 3;
+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_599], 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];
@@ -50985,12 +49526,12 @@ fn aiur_fn_599(
         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_599] = [__v_8];
-        record.function_queries[599].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);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_4]; 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 __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];
@@ -51007,18 +49548,18 @@ fn aiur_fn_599(
         match __v_7.as_canonical_u64() {
           5u64 => {
             let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_8, __v_18]; 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 __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_8, __v_18]; 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_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_599] = { let __args: [G; IN_599] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __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_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_599] = [__v_26];
-            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_580] = [__v_26];
+            record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -51030,11 +49571,11 @@ fn aiur_fn_599(
             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_599] = { let __args: [G; IN_599] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __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_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_599] = [__v_27];
-            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_580] = [__v_27];
+            record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51046,15 +49587,15 @@ fn aiur_fn_599(
   })
 }
 
-const INPUT_SIZE_600: usize = 1;
-const IN_600: usize = 1;
-const OUT_600: usize = 1;
-fn aiur_fn_600(
-  inp: [G; IN_600],
+const INPUT_SIZE_581: usize = 1;
+const IN_581: usize = 1;
+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_600], ExecError> {
+) -> Result<[G; OUT_581], 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 };
@@ -51069,17 +49610,17 @@ fn aiur_fn_600(
         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_600] = [__v_9];
-        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_581] = [__v_9];
+        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_6]; 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 __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6]; 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_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_600] = [__v_9];
-        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_581] = [__v_9];
+        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51089,15 +49630,15 @@ fn aiur_fn_600(
   })
 }
 
-const INPUT_SIZE_601: usize = 2;
-const IN_601: usize = 2;
-const OUT_601: usize = 4;
-fn aiur_fn_601(
-  inp: [G; IN_601],
+const INPUT_SIZE_582: usize = 2;
+const IN_582: usize = 2;
+const OUT_582: usize = 4;
+fn aiur_fn_582(
+  inp: [G; IN_582],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_601], 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];
@@ -51118,27 +49659,27 @@ fn aiur_fn_601(
         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_601] = [__v_8, __v_9, __v_12, __v_15];
-        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_582] = [__v_8, __v_9, __v_12, __v_15];
+        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_601] = [__v_3, __v_4, __v_5, __v_6];
-            record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_582] = [__v_3, __v_4, __v_5, __v_6];
+            record.function_queries[582].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_601] = { let __args: [G; IN_601] = [__v_7, __v_9]; 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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_7, __v_9]; 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_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_601] = [__v_10, __v_11, __v_12, __v_13];
-            record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_582] = [__v_10, __v_11, __v_12, __v_13];
+            record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51150,31 +49691,31 @@ fn aiur_fn_601(
   })
 }
 
-const INPUT_SIZE_602: usize = 4;
-const IN_602: usize = 4;
-const OUT_602: usize = 1;
-fn aiur_fn_602(
-  inp: [G; IN_602],
+const INPUT_SIZE_583: usize = 4;
+const IN_583: usize = 4;
+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_602], 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 __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_0, __v_1]; 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_768] = { let __args: [G; IN_768] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_1]; 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 __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_6]; 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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_6]; 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_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_781] = { let __args: [G; IN_781] = [__v_2, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_7]; 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 __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];
@@ -51190,16 +49731,16 @@ fn aiur_fn_602(
     let __v_22: G = __loaded[10];
     match __v_12.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_14, __v_15]; 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 __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_14, __v_15]; 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_23: G = __r_arr[0];
         let __v_24: G = __r_arr[1];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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_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_767] = { let __args: [G; IN_767] = [__v_5]; 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 __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_603] = { let __args: [G; IN_603] = [__v_28, __v_26]; 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 __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_28, __v_26]; 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_29: G = __r_arr[0];
         let __v_30: G = G::from_u64(1);
         let __v_31: G = G::from_u64(1);
@@ -51207,36 +49748,36 @@ fn aiur_fn_602(
         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_605] = { let __args: [G; IN_605] = [__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[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 __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__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[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_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_36]; 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 __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_36]; 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_37, __v_5]; 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 __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_37, __v_5]; 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_4, __v_38]; 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_756] = { let __args: [G; IN_756] = [__v_4, __v_38]; 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_39: G = __r_arr[0];
-        let __ret: [G; OUT_602] = [__v_39];
-        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_583] = [__v_39];
+        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_602] = [__v_0];
-        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_583] = [__v_0];
+        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_603: usize = 2;
-const IN_603: usize = 2;
-const OUT_603: usize = 1;
-fn aiur_fn_603(
-  inp: [G; IN_603],
+const INPUT_SIZE_584: usize = 2;
+const IN_584: usize = 2;
+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_603], ExecError> {
+) -> 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];
@@ -51246,34 +49787,34 @@ fn aiur_fn_603(
         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_603] = [__v_5];
-        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_584] = [__v_5];
+        record.function_queries[584].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_603] = { let __args: [G; IN_603] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_1]; 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_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_603] = [__v_7];
-        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_584] = [__v_7];
+        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_585: usize = 2;
+const IN_585: usize = 2;
+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_604], ExecError> {
+) -> 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];
@@ -51286,22 +49827,22 @@ fn aiur_fn_604(
         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_604] = [__v_7];
-        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_585] = [__v_7];
+        record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_1, __v_3]; 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_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_604] = { let __args: [G; IN_604] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_1]; 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_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_604] = [__v_11];
-        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_585] = [__v_11];
+        record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51311,15 +49852,15 @@ fn aiur_fn_604(
   })
 }
 
-const INPUT_SIZE_605: usize = 9;
-const IN_605: usize = 9;
-const OUT_605: usize = 1;
-fn aiur_fn_605(
-  inp: [G; IN_605],
+const INPUT_SIZE_586: usize = 9;
+const IN_586: usize = 9;
+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_605], ExecError> {
+) -> 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];
@@ -51332,31 +49873,31 @@ fn aiur_fn_605(
     let __v_8: G = inp[8];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_605] = [__v_0];
-        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_586] = [__v_0];
+        record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_5, __v_9]; 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 __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_5, __v_9]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__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[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 __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__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[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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_11]; 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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_0, __v_11]; 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_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_605] = [__v_0];
-            record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_586] = [__v_0];
+            record.function_queries[586].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_605] = { let __args: [G; IN_605] = [__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[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 __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__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[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_15: G = __r_arr[0];
-            let __ret: [G; OUT_605] = [__v_15];
-            record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_586] = [__v_15];
+            record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51365,15 +49906,15 @@ fn aiur_fn_605(
   })
 }
 
-const INPUT_SIZE_606: usize = 3;
-const IN_606: usize = 3;
-const OUT_606: usize = 1;
-fn aiur_fn_606(
-  inp: [G; IN_606],
+const INPUT_SIZE_587: usize = 3;
+const IN_587: usize = 3;
+const OUT_587: usize = 1;
+fn aiur_fn_587(
+  inp: [G; IN_587],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_606], 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];
@@ -51387,21 +49928,21 @@ fn aiur_fn_606(
         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_606] = [__v_8];
-        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_587] = [__v_8];
+        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_4, __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 __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __v_1, __v_2]; 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_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_606] = { let __args: [G; IN_606] = [__v_5, __v_1, __v_8]; 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 __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_5, __v_1, __v_8]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_6, __v_9]; 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 __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6, __v_9]; 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_606] = [__v_10];
-        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_587] = [__v_10];
+        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51411,15 +49952,15 @@ fn aiur_fn_606(
   })
 }
 
-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_588: usize = 3;
+const IN_588: usize = 3;
+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_607], 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];
@@ -51433,18 +49974,18 @@ fn aiur_fn_607(
         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_607] = [__v_8];
-        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_588] = [__v_8];
+        record.function_queries[588].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_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 __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_5, __v_1, __v_2]; 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_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_607] = [__v_9];
-        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_588] = [__v_9];
+        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51454,15 +49995,15 @@ fn aiur_fn_607(
   })
 }
 
-const INPUT_SIZE_608: usize = 9;
-const IN_608: usize = 9;
-const OUT_608: usize = 1;
-fn aiur_fn_608(
-  inp: [G; IN_608],
+const INPUT_SIZE_589: usize = 9;
+const IN_589: usize = 9;
+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_608], ExecError> {
+) -> 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];
@@ -51482,19 +50023,19 @@ fn aiur_fn_608(
         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_608] = [__v_14];
-        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_589] = [__v_14];
+        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__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[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 __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__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[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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__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[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 __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__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[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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_12, __v_13]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_12, __v_13]; 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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_608] = [__v_14];
-        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_589] = [__v_14];
+        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51504,15 +50045,15 @@ fn aiur_fn_608(
   })
 }
 
-const INPUT_SIZE_609: usize = 9;
-const IN_609: usize = 9;
-const OUT_609: usize = 1;
-fn aiur_fn_609(
-  inp: [G; IN_609],
+const INPUT_SIZE_590: usize = 9;
+const IN_590: usize = 9;
+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_609], ExecError> {
+) -> 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];
@@ -51523,15 +50064,15 @@ fn aiur_fn_609(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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_609] = [__v_12];
-        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_590] = [__v_12];
+        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -51540,32 +50081,32 @@ fn aiur_fn_609(
         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_609] = [__v_14];
-        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_590] = [__v_14];
+        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__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[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 __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__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[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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__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[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 __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__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[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_11: G = __r_arr[0];
-        let __ret: [G; OUT_609] = [__v_11];
-        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_590] = [__v_11];
+        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_610: usize = 9;
-const IN_610: usize = 9;
-const OUT_610: usize = 1;
-fn aiur_fn_610(
-  inp: [G; IN_610],
+const INPUT_SIZE_591: usize = 9;
+const IN_591: usize = 9;
+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_610], ExecError> {
+) -> 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];
@@ -51585,17 +50126,17 @@ fn aiur_fn_610(
         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_610] = [__v_14];
-        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_591] = [__v_14];
+        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__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[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 __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__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[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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__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[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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__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[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_13: G = __r_arr[0];
-        let __ret: [G; OUT_610] = [__v_13];
-        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_591] = [__v_13];
+        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51605,15 +50146,15 @@ fn aiur_fn_610(
   })
 }
 
-const INPUT_SIZE_611: usize = 10;
-const IN_611: usize = 10;
-const OUT_611: usize = 1;
-fn aiur_fn_611(
-  inp: [G; IN_611],
+const INPUT_SIZE_592: usize = 10;
+const IN_592: usize = 10;
+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_611], 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];
@@ -51636,29 +50177,29 @@ fn aiur_fn_611(
         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_611] = [__v_17];
-        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_592] = [__v_17];
+        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__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[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 __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__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[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_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_611] = { let __args: [G; IN_611] = [__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[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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__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[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_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_611] = [__v_17];
-            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_592] = [__v_17];
+            record.function_queries[592].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_611] = [__v_16];
-            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_592] = [__v_16];
+            record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51670,15 +50211,15 @@ fn aiur_fn_611(
   })
 }
 
-const INPUT_SIZE_612: usize = 9;
-const IN_612: usize = 9;
-const OUT_612: usize = 1;
-fn aiur_fn_612(
-  inp: [G; IN_612],
+const INPUT_SIZE_593: usize = 9;
+const IN_593: usize = 9;
+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_612], ExecError> {
+) -> 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];
@@ -51698,8 +50239,8 @@ fn aiur_fn_612(
         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_612] = [__v_14];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_593] = [__v_14];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -51708,10 +50249,10 @@ fn aiur_fn_612(
         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_613] = { let __args: [G; IN_613] = [__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[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 __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__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[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_17: G = __r_arr[0];
-        let __ret: [G; OUT_612] = [__v_17];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_593] = [__v_17];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51721,15 +50262,15 @@ fn aiur_fn_612(
   })
 }
 
-const INPUT_SIZE_613: usize = 11;
-const IN_613: usize = 11;
-const OUT_613: usize = 1;
-fn aiur_fn_613(
-  inp: [G; IN_613],
+const INPUT_SIZE_594: usize = 11;
+const IN_594: usize = 11;
+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_613], 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];
@@ -51753,22 +50294,22 @@ fn aiur_fn_613(
         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_613] = [__v_18];
-        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_594] = [__v_18];
+        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__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[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 __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__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[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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_12]; 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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_10, __v_12]; 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 __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__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[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 __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__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[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_17: G = __r_arr[0];
-            let __ret: [G; OUT_613] = [__v_17];
-            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_594] = [__v_17];
+            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -51778,11 +50319,11 @@ fn aiur_fn_613(
             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_613] = { let __args: [G; IN_613] = [__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[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 __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__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[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_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_613] = [__v_23];
-            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_594] = [__v_23];
+            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51794,15 +50335,15 @@ fn aiur_fn_613(
   })
 }
 
-const INPUT_SIZE_614: usize = 10;
-const IN_614: usize = 10;
-const OUT_614: usize = 2;
-fn aiur_fn_614(
-  inp: [G; IN_614],
+const INPUT_SIZE_595: usize = 10;
+const IN_595: usize = 10;
+const OUT_595: usize = 2;
+fn aiur_fn_595(
+  inp: [G; IN_595],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_614], ExecError> {
+) -> 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];
@@ -51814,17 +50355,17 @@ fn aiur_fn_614(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_3, __v_0]; 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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3, __v_0]; 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_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_601] = { let __args: [G; IN_601] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3, __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_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_781] = { let __args: [G; IN_781] = [__v_8, __v_10]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_8, __v_10]; 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 __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];
@@ -51838,7 +50379,7 @@ fn aiur_fn_614(
     let __v_27: G = __loaded[8];
     let __v_28: G = __loaded[9];
     let __v_29: G = __loaded[10];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_8, __v_14]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_8, __v_14]; 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 __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];
@@ -51856,74 +50397,74 @@ fn aiur_fn_614(
       5u64 => {
         match __v_31.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_23, __v_35]; 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_626] = { let __args: [G; IN_626] = [__v_23, __v_35]; 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_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_42]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_42]; 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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_24]; 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 __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_200] = { let __args: [G; IN_200] = [__v_36]; 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 __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_645] = { let __args: [G; IN_645] = [__v_45, __v_46]; 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_626] = { let __args: [G; IN_626] = [__v_45, __v_46]; 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_47: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_47]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__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_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__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[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 __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__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[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_50: G = __r_arr[0];
-            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__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[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 __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__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[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_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_50, __v_51, __v_2, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_50, __v_51, __v_2, __v_9]; 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__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[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 __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__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[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_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_52, __v_53, __v_54, __v_55]; 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_631] = { let __args: [G; IN_631] = [__v_52, __v_53, __v_54, __v_55]; 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_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_48, __v_49, __v_56, __v_57]; 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_631] = { let __args: [G; IN_631] = [__v_48, __v_49, __v_56, __v_57]; 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_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_43, __v_44, __v_58, __v_59]; 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_631] = { let __args: [G; IN_631] = [__v_43, __v_44, __v_58, __v_59]; 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_60: G = __r_arr[0];
             let __v_61: G = __r_arr[1];
-            let __ret: [G; OUT_614] = [__v_60, __v_61];
-            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_595] = [__v_60, __v_61];
+            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __ret: [G; OUT_614] = [__v_42, __v_43];
-            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_595] = [__v_42, __v_43];
+            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_42: G = __r_arr[0];
         let __v_43: G = __r_arr[1];
-        let __ret: [G; OUT_614] = [__v_42, __v_43];
-        record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_595] = [__v_42, __v_43];
+        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_615: usize = 11;
-const IN_615: usize = 11;
-const OUT_615: usize = 1;
-fn aiur_fn_615(
-  inp: [G; IN_615],
+const INPUT_SIZE_596: usize = 11;
+const IN_596: usize = 11;
+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_615], 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];
@@ -51936,31 +50477,31 @@ fn aiur_fn_615(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_3]; 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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_11, __v_1, __v_2, __v_12, __v_9, __v_10]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_1, __v_2, __v_12, __v_9, __v_10]; 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_13: G = __r_arr[0];
     let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_13, __v_4, __v_5, __v_6, __v_8, __v_14]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_4, __v_5, __v_6, __v_8, __v_14]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_15, __v_7]; 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_615] = [__v_16];
-    record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_596] = [__v_16];
+    record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_616: usize = 16;
-const IN_616: usize = 16;
-const OUT_616: usize = 2;
-fn aiur_fn_616(
-  inp: [G; IN_616],
+const INPUT_SIZE_597: usize = 16;
+const IN_597: usize = 16;
+const OUT_597: usize = 2;
+fn aiur_fn_597(
+  inp: [G; IN_597],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_616], ExecError> {
+) -> 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];
@@ -51984,11 +50525,11 @@ fn aiur_fn_616(
     let __v_18: G = __loaded[2];
     match __v_16.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __ret: [G; OUT_616] = [__v_19, __v_20];
-        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_597] = [__v_19, __v_20];
+        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -51998,15 +50539,15 @@ fn aiur_fn_616(
         let __v_21: G = __loaded[2];
         match __v_19.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_616] = [__v_22, __v_23];
-            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_597] = [__v_22, __v_23];
+            record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_14, __v_17]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_14, __v_17]; 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 __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];
@@ -52020,7 +50561,7 @@ fn aiur_fn_616(
             let __v_31: G = __loaded[8];
             let __v_32: G = __loaded[9];
             let __v_33: G = __loaded[10];
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_14, __v_20]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_14, __v_20]; 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 __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];
@@ -52038,47 +50579,47 @@ fn aiur_fn_616(
               6u64 => {
                 match __v_35.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_29, __v_41]; 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_626] = { let __args: [G; IN_626] = [__v_29, __v_41]; 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_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_46]; 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_47: G = __r_arr[0];
                     let __v_48: G = __r_arr[1];
-                    let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__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[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 __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__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[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_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__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[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 __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__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[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_50: G = __r_arr[0];
-                    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_49, __v_50, __v_13, __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)? } };
+                    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_49, __v_50, __v_13, __v_15]; 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_51: G = __r_arr[0];
                     let __v_52: G = __r_arr[1];
-                    let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__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[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 __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__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[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 = __r_arr[1];
-                    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_51, __v_52, __v_53, __v_54]; 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_631] = { let __args: [G; IN_631] = [__v_51, __v_52, __v_53, __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 = __r_arr[1];
-                    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_47, __v_48, __v_55, __v_56]; 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_631] = { let __args: [G; IN_631] = [__v_47, __v_48, __v_55, __v_56]; 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_57: G = __r_arr[0];
                     let __v_58: G = __r_arr[1];
-                    let __ret: [G; OUT_616] = [__v_57, __v_58];
-                    record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_597] = [__v_57, __v_58];
+                    record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_46: G = __r_arr[0];
                     let __v_47: G = __r_arr[1];
-                    let __ret: [G; OUT_616] = [__v_46, __v_47];
-                    record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_597] = [__v_46, __v_47];
+                    record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_46: G = __r_arr[0];
                 let __v_47: G = __r_arr[1];
-                let __ret: [G; OUT_616] = [__v_46, __v_47];
-                record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_597] = [__v_46, __v_47];
+                record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -52095,15 +50636,15 @@ fn aiur_fn_616(
   })
 }
 
-const INPUT_SIZE_617: usize = 11;
-const IN_617: usize = 11;
-const OUT_617: usize = 1;
-fn aiur_fn_617(
-  inp: [G; IN_617],
+const INPUT_SIZE_598: usize = 11;
+const IN_598: usize = 11;
+const OUT_598: usize = 1;
+fn aiur_fn_598(
+  inp: [G; IN_598],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_617], ExecError> {
+) -> 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];
@@ -52116,28 +50657,28 @@ fn aiur_fn_617(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_2, __v_3, __v_9, __v_10]; 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 __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_9, __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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_4, __v_5, __v_6, __v_8, __v_12]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_4, __v_5, __v_6, __v_8, __v_12]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_13, __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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_13, __v_7]; 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_14: G = __r_arr[0];
-    let __ret: [G; OUT_617] = [__v_14];
-    record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_598] = [__v_14];
+    record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_618: usize = 6;
-const IN_618: usize = 6;
-const OUT_618: usize = 1;
-fn aiur_fn_618(
-  inp: [G; IN_618],
+const INPUT_SIZE_599: usize = 6;
+const IN_599: usize = 6;
+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_618], ExecError> {
+) -> 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];
@@ -52145,13 +50686,13 @@ fn aiur_fn_618(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_618] = [__v_7];
-        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_599] = [__v_7];
+        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52163,71 +50704,71 @@ fn aiur_fn_618(
         match __v_8.as_canonical_u64() {
           3u64 => {
             let __v_12: G = G::from_u64(3);
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_618] = [__v_16];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_16];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_12: G = G::from_u64(4);
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_618] = { let __args: [G; IN_618] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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_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_618] = [__v_18];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_18];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             let __v_12: G = G::from_u64(5);
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_618] = { let __args: [G; IN_618] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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_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_618] = [__v_18];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_18];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
             let __v_12: G = G::from_u64(6);
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_618] = { let __args: [G; IN_618] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_16]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_16]; 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_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_618] = [__v_18];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_18];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           8u64 => {
             let __v_12: G = G::from_u64(8);
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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_618] = [__v_14];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_14];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_618] = [__v_0];
-            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_0];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52236,15 +50777,15 @@ fn aiur_fn_618(
   })
 }
 
-const INPUT_SIZE_619: usize = 6;
-const IN_619: usize = 6;
-const OUT_619: usize = 2;
-fn aiur_fn_619(
-  inp: [G; IN_619],
+const INPUT_SIZE_600: usize = 6;
+const IN_600: usize = 6;
+const OUT_600: usize = 2;
+fn aiur_fn_600(
+  inp: [G; IN_600],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_619], 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];
@@ -52252,7 +50793,7 @@ fn aiur_fn_619(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    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 __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 };
@@ -52263,32 +50804,32 @@ fn aiur_fn_619(
     match __v_8.as_canonical_u64() {
       2u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__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[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 __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__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[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 __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_619] = [__v_13, __v_14];
-        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_600] = [__v_13, __v_14];
+        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_619] = [__v_12, __v_0];
-        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_600] = [__v_12, __v_0];
+        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_620: usize = 9;
-const IN_620: usize = 9;
-const OUT_620: usize = 2;
-fn aiur_fn_620(
-  inp: [G; IN_620],
+const INPUT_SIZE_601: usize = 9;
+const IN_601: usize = 9;
+const OUT_601: usize = 2;
+fn aiur_fn_601(
+  inp: [G; IN_601],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_620], 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];
@@ -52309,42 +50850,42 @@ fn aiur_fn_620(
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_620] = [__v_15, __v_0];
-        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_601] = [__v_15, __v_0];
+        record.function_queries[601].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_200] = { let __args: [G; IN_200] = [__v_12]; 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 __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_200] = { let __args: [G; IN_200] = [__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 __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_620] = { let __args: [G; IN_620] = [__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[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 __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__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[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_21: G = __r_arr[0];
                 let __v_22: G = __r_arr[1];
-                let __ret: [G; OUT_620] = [__v_21, __v_22];
-                record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_601] = [__v_21, __v_22];
+                record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_12, __v_7]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_12, __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_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_620] = { let __args: [G; IN_620] = [__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[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 __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__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[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_22: G = __r_arr[0];
                     let __v_23: G = __r_arr[1];
-                    let __ret: [G; OUT_620] = [__v_22, __v_23];
-                    record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_601] = [__v_22, __v_23];
+                    record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -52353,15 +50894,15 @@ fn aiur_fn_620(
                     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_622] = { let __args: [G; IN_622] = [__v_23, __v_5, __v_7, __v_24]; 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 __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_23, __v_5, __v_7, __v_24]; 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_25: G = __r_arr[0];
                     let __v_26: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__v_2, __v_16]; 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_769] = { let __args: [G; IN_769] = [__v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
                     let __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_25, __v_27]; 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_400] = { let __args: [G; IN_400] = [__v_25, __v_27]; 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_28: G = __r_arr[0];
-                    let __ret: [G; OUT_620] = [__v_26, __v_28];
-                    record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_601] = [__v_26, __v_28];
+                    record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -52377,11 +50918,11 @@ fn aiur_fn_620(
           _ => {
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_8 + __v_16);
-            let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__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[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 __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__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[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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_620] = [__v_18, __v_19];
-            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_601] = [__v_18, __v_19];
+            record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52393,15 +50934,15 @@ fn aiur_fn_620(
   })
 }
 
-const INPUT_SIZE_621: usize = 3;
-const IN_621: usize = 3;
-const OUT_621: usize = 1;
-fn aiur_fn_621(
-  inp: [G; IN_621],
+const INPUT_SIZE_602: usize = 3;
+const IN_602: usize = 3;
+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_621], ExecError> {
+) -> 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];
@@ -52413,8 +50954,8 @@ fn aiur_fn_621(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_621] = [__v_6];
-        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_602] = [__v_6];
+        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -52425,28 +50966,28 @@ fn aiur_fn_621(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_621] = [__v_9];
-            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_602] = [__v_9];
+            record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __v_2, __v_9]; 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_386] = { let __args: [G; IN_386] = [__v_4, __v_2, __v_9]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_7, __v_10]; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_7, __v_10]; 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 __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_8, __v_5, __v_2]; 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 __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_8, __v_5, __v_2]; 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_12: G = __r_arr[0];
-                let __ret: [G; OUT_621] = [__v_12];
-                record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_602] = [__v_12];
+                record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_621] = [__v_12];
-                record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_602] = [__v_12];
+                record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -52463,15 +51004,15 @@ fn aiur_fn_621(
   })
 }
 
-const INPUT_SIZE_622: usize = 4;
-const IN_622: usize = 4;
-const OUT_622: usize = 1;
-fn aiur_fn_622(
-  inp: [G; IN_622],
+const INPUT_SIZE_603: usize = 4;
+const IN_603: usize = 4;
+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_622], ExecError> {
+) -> 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];
@@ -52480,8 +51021,8 @@ fn aiur_fn_622(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_622] = [__v_0];
-        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_603] = [__v_0];
+        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52497,25 +51038,25 @@ fn aiur_fn_622(
         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_622] = { let __args: [G; IN_622] = [__v_14, __v_1, __v_2, __v_16]; 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 __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_14, __v_1, __v_2, __v_16]; 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 __ret: [G; OUT_622] = [__v_17];
-        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_603] = [__v_17];
+        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_623: usize = 6;
-const IN_623: usize = 6;
-const OUT_623: usize = 1;
-fn aiur_fn_623(
-  inp: [G; IN_623],
+const INPUT_SIZE_604: usize = 6;
+const IN_604: usize = 6;
+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_623], 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];
@@ -52526,32 +51067,32 @@ fn aiur_fn_623(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_6]; 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1, __v_2, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_623] = [__v_7];
-        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_604] = [__v_7];
+        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_5, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_5, __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_6: G = __r_arr[0];
-        let __ret: [G; OUT_623] = [__v_6];
-        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_604] = [__v_6];
+        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_624: usize = 2;
-const IN_624: usize = 2;
-const OUT_624: usize = 1;
-fn aiur_fn_624(
-  inp: [G; IN_624],
+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_624], 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];
@@ -52567,12 +51108,12 @@ fn aiur_fn_624(
         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_624] = [__v_10];
-        record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_605] = [__v_10];
+        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_3]; 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 __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];
@@ -52589,21 +51130,21 @@ fn aiur_fn_624(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_7, __v_1]; 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 __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_7, __v_1]; 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_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_624] = [__v_22];
-            record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_605] = [__v_22];
+            record.function_queries[605].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_624] = { let __args: [G; IN_624] = [__v_7, __v_1]; 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 __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_7, __v_1]; 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_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_624] = [__v_23];
-            record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_605] = [__v_23];
+            record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52615,15 +51156,15 @@ fn aiur_fn_624(
   })
 }
 
-const INPUT_SIZE_625: usize = 3;
-const IN_625: usize = 3;
-const OUT_625: usize = 1;
-fn aiur_fn_625(
-  inp: [G; IN_625],
+const INPUT_SIZE_606: usize = 3;
+const IN_606: usize = 3;
+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_625], 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];
@@ -52661,28 +51202,28 @@ fn aiur_fn_625(
     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_130] = { let __args: [G; IN_130] = [__v_1, __v_35]; 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 __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_625] = [__v_0];
-        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_606] = [__v_0];
+        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_37: G = G::from_u64(0);
-        let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_2, __v_37]; 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 __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_2, __v_37]; 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_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         match __v_38.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_625] = [__v_39];
-            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_606] = [__v_39];
+            record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_625] = [__v_0];
-            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_606] = [__v_0];
+            record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52694,20 +51235,20 @@ fn aiur_fn_625(
   })
 }
 
-const INPUT_SIZE_626: usize = 3;
-const IN_626: usize = 3;
-const OUT_626: usize = 1;
-fn aiur_fn_626(
-  inp: [G; IN_626],
+const INPUT_SIZE_607: usize = 3;
+const IN_607: usize = 3;
+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_626], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_1, __v_2]; 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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_1, __v_2]; 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_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];
@@ -52718,29 +51259,29 @@ fn aiur_fn_626(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_626] = [__v_9];
-        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_607] = [__v_9];
+        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_626] = [__v_9];
-        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_607] = [__v_9];
+        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_627: usize = 3;
-const IN_627: usize = 3;
-const OUT_627: usize = 1;
-fn aiur_fn_627(
-  inp: [G; IN_627],
+const INPUT_SIZE_608: usize = 3;
+const IN_608: usize = 3;
+const OUT_608: usize = 1;
+fn aiur_fn_608(
+  inp: [G; IN_608],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_627], 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];
@@ -52752,25 +51293,25 @@ fn aiur_fn_627(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_627] = [__v_6];
-        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_608] = [__v_6];
+        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_4, __v_1, __v_2]; 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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_4, __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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_627] = [__v_7];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_608] = [__v_7];
+            record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_1, __v_2]; 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 __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_5, __v_1, __v_2]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_627] = [__v_7];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_608] = [__v_7];
+            record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -52785,37 +51326,37 @@ fn aiur_fn_627(
   })
 }
 
-const INPUT_SIZE_628: usize = 2;
-const IN_628: usize = 2;
-const OUT_628: usize = 1;
-fn aiur_fn_628(
-  inp: [G; IN_628],
+const INPUT_SIZE_609: usize = 2;
+const IN_609: usize = 2;
+const OUT_609: usize = 1;
+fn aiur_fn_609(
+  inp: [G; IN_609],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_628], 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 __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __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 __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_2, __v_2, __v_1]; 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 __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_2, __v_1]; 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_628] = [__v_3];
-    record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_609] = [__v_3];
+    record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_629: usize = 4;
-const IN_629: usize = 4;
-const OUT_629: usize = 2;
-fn aiur_fn_629(
-  inp: [G; IN_629],
+const INPUT_SIZE_610: usize = 4;
+const IN_610: usize = 4;
+const OUT_610: usize = 2;
+fn aiur_fn_610(
+  inp: [G; IN_610],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_629], ExecError> {
+) -> 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];
@@ -52829,8 +51370,8 @@ fn aiur_fn_629(
       1u64 => {
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_629] = [__v_7, __v_8];
-        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_610] = [__v_7, __v_8];
+        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -52848,23 +51389,23 @@ fn aiur_fn_629(
         let __v_17: G = __loaded[10];
         match __v_7.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_0]; 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 __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_629] = { let __args: [G; IN_629] = [__v_0, __v_6, __v_2, __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 __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_6, __v_2, __v_20]; 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_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));
+                let __ret: [G; OUT_610] = [__v_21, __v_22];
+                record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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 __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_19]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_19]; 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 __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];
@@ -52880,23 +51421,23 @@ fn aiur_fn_629(
                 let __v_31: G = __loaded[10];
                 match __v_21.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_19, __v_2]; 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_19, __v_2]; 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_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_629] = { let __args: [G; IN_629] = [__v_0, __v_6, __v_2, __v_34]; 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 __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_6, __v_2, __v_34]; 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_35: G = __r_arr[0];
                         let __v_36: G = __r_arr[1];
-                        let __ret: [G; OUT_629] = [__v_35, __v_36];
-                        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_610] = [__v_35, __v_36];
+                        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_33: G = G::from_u64(1);
-                        let __ret: [G; OUT_629] = [__v_33, __v_19];
-                        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_610] = [__v_33, __v_19];
+                        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -52904,11 +51445,11 @@ fn aiur_fn_629(
                   _ => {
                     let __v_32: G = G::from_u64(1);
                     let __v_33: G = (__v_3 + __v_32);
-                    let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_6, __v_2, __v_33]; 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 __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_6, __v_2, __v_33]; 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_34: G = __r_arr[0];
                     let __v_35: G = __r_arr[1];
-                    let __ret: [G; OUT_629] = [__v_34, __v_35];
-                    record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_610] = [__v_34, __v_35];
+                    record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -52921,11 +51462,11 @@ fn aiur_fn_629(
           _ => {
             let __v_18: G = G::from_u64(1);
             let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_6, __v_2, __v_19]; 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 __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_6, __v_2, __v_19]; 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_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
-            let __ret: [G; OUT_629] = [__v_20, __v_21];
-            record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_610] = [__v_20, __v_21];
+            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52937,15 +51478,15 @@ fn aiur_fn_629(
   })
 }
 
-const INPUT_SIZE_630: usize = 4;
-const IN_630: usize = 4;
-const OUT_630: usize = 1;
-fn aiur_fn_630(
-  inp: [G; IN_630],
+const INPUT_SIZE_611: usize = 4;
+const IN_611: usize = 4;
+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_630], 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];
@@ -52953,8 +51494,8 @@ fn aiur_fn_630(
     let __v_3: G = inp[3];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_630] = [__v_3];
-        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_611] = [__v_3];
+        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52964,12 +51505,12 @@ fn aiur_fn_630(
         let __v_6: G = __loaded[2];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_630] = [__v_3];
-            record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_611] = [__v_3];
+            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_5]; 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 __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];
@@ -52987,22 +51528,22 @@ fn aiur_fn_630(
               5u64 => {
                 let __v_19: G = G::from_u64(1);
                 let __v_20: G = (__v_1 - __v_19);
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_13]; 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 __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_630] = { let __args: [G; IN_630] = [__v_6, __v_20, __v_2, __v_22]; 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 __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_20, __v_2, __v_22]; 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_630] = [__v_23];
-                record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_611] = [__v_23];
+                record.function_queries[611].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_630] = { let __args: [G; IN_630] = [__v_6, __v_20, __v_2, __v_3]; 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 __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_20, __v_2, __v_3]; 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_21: G = __r_arr[0];
-                let __ret: [G; OUT_630] = [__v_21];
-                record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_611] = [__v_21];
+                record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -53016,20 +51557,20 @@ fn aiur_fn_630(
   })
 }
 
-const INPUT_SIZE_631: usize = 3;
-const IN_631: usize = 3;
-const OUT_631: usize = 1;
-fn aiur_fn_631(
-  inp: [G; IN_631],
+const INPUT_SIZE_612: usize = 3;
+const IN_612: usize = 3;
+const OUT_612: usize = 1;
+fn aiur_fn_612(
+  inp: [G; IN_612],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_631], 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 = inp[2];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_0]; 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 __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];
@@ -53045,33 +51586,33 @@ fn aiur_fn_631(
     let __v_14: G = __loaded[10];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_9, __v_7, __v_1, __v_2]; 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 __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_9, __v_7, __v_1, __v_2]; 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_631] = [__v_15];
-        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_612] = [__v_15];
+        record.function_queries[612].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_631] = [__v_17];
-        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_612] = [__v_17];
+        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_632: usize = 4;
-const IN_632: usize = 4;
-const OUT_632: usize = 1;
-fn aiur_fn_632(
-  inp: [G; IN_632],
+const INPUT_SIZE_613: usize = 4;
+const IN_613: usize = 4;
+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_632], 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];
@@ -53086,12 +51627,12 @@ fn aiur_fn_632(
         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_632] = [__v_9];
-        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_613] = [__v_9];
+        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_5]; 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 __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];
@@ -53107,24 +51648,24 @@ fn aiur_fn_632(
         let __v_18: G = __loaded[10];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_10, __v_1]; 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_19: G = __r_arr[0];
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_19, __v_2, __v_3, __v_20]; 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 __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_19, __v_2, __v_3, __v_20]; 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_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_6, __v_1, __v_2, __v_3]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_21, __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 __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_21, __v_22]; 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 __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_632] = [__v_23];
-            record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_613] = [__v_23];
+            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_6, __v_1, __v_2, __v_3]; 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_19: G = __r_arr[0];
-            let __ret: [G; OUT_632] = [__v_19];
-            record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_613] = [__v_19];
+            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -53136,15 +51677,15 @@ fn aiur_fn_632(
   })
 }
 
-const INPUT_SIZE_633: usize = 4;
-const IN_633: usize = 4;
-const OUT_633: usize = 1;
-fn aiur_fn_633(
-  inp: [G; IN_633],
+const INPUT_SIZE_614: usize = 4;
+const IN_614: usize = 4;
+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_633], 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];
@@ -53157,48 +51698,48 @@ fn aiur_fn_633(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_1, __v_2, __v_3]; 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 = G::from_u64(1);
         let __v_10: G = (__v_3 + __v_9);
-        let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_6, __v_1, __v_2, __v_10]; 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 __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_6, __v_1, __v_2, __v_10]; 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_11: G = __r_arr[0];
-        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 __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_8, __v_11]; 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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_633] = [__v_12];
-        record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_614] = [__v_12];
+        record.function_queries[614].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_633] = [__v_10];
-        record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_614] = [__v_10];
+        record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_634: usize = 4;
-const IN_634: usize = 4;
-const OUT_634: usize = 1;
-fn aiur_fn_634(
-  inp: [G; IN_634],
+const INPUT_SIZE_615: usize = 4;
+const IN_615: usize = 4;
+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_634], ExecError> {
+) -> 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 __v_3: G = inp[3];
-    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0]; 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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_0]; 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5]; 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 __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 };
@@ -53208,19 +51749,19 @@ fn aiur_fn_634(
     let __v_11: G = __loaded[3];
     match __v_8.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_9]; 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_503] = { let __args: [G; IN_503] = [__v_1, __v_9]; 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_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_634] = [__v_15];
-            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_615] = [__v_15];
+            record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_9]; 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 __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];
@@ -53236,7 +51777,7 @@ fn aiur_fn_634(
             let __v_24: G = __loaded[10];
             match __v_14.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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() {
@@ -53244,49 +51785,49 @@ fn aiur_fn_634(
                     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_634] = [__v_29];
-                    record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_615] = [__v_29];
+                    record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_7, __v_17]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_7, __v_17]; 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 __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_27, __v_1]; 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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_27, __v_1]; 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_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_634] = [__v_31];
-                        record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_615] = [__v_31];
+                        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
-                        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; 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 __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_635] = { let __args: [G; IN_635] = [__v_27, __v_30]; 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 __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_27, __v_30]; 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_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_634] = [__v_34];
-                            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_615] = [__v_34];
+                            record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_27, __v_30]; 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 __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_27, __v_30]; 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_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_634] = [__v_37];
-                            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_615] = [__v_37];
+                            record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -53308,8 +51849,8 @@ fn aiur_fn_634(
                 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_634] = [__v_27];
-                record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_615] = [__v_27];
+                record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -53323,23 +51864,23 @@ fn aiur_fn_634(
         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_634] = [__v_14];
-        record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_615] = [__v_14];
+        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_635: usize = 2;
-const IN_635: usize = 2;
-const OUT_635: usize = 1;
-fn aiur_fn_635(
-  inp: [G; IN_635],
+const INPUT_SIZE_616: usize = 2;
+const IN_616: usize = 2;
+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_635], 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];
@@ -53350,26 +51891,26 @@ fn aiur_fn_635(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_635] = [__v_5];
-        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_616] = [__v_5];
+        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_3, __v_5, __v_1]; 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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_3, __v_5, __v_1]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_635] = [__v_7];
-            record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].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]; 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 __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_635] = [__v_7];
-            record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53384,15 +51925,15 @@ fn aiur_fn_635(
   })
 }
 
-const INPUT_SIZE_636: usize = 2;
-const IN_636: usize = 2;
-const OUT_636: usize = 1;
-fn aiur_fn_636(
-  inp: [G; IN_636],
+const INPUT_SIZE_617: usize = 2;
+const IN_617: usize = 2;
+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_636], 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];
@@ -53405,20 +51946,20 @@ fn aiur_fn_636(
         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_636] = [__v_7];
-        record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_617] = [__v_7];
+        record.function_queries[617].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_404] = { let __args: [G; IN_404] = [__v_3, __v_1, __v_6]; 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_390] = { let __args: [G; IN_390] = [__v_3, __v_1, __v_6]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __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 __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; 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_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_636] = [__v_9];
-        record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_617] = [__v_9];
+        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53428,15 +51969,15 @@ fn aiur_fn_636(
   })
 }
 
-const INPUT_SIZE_637: usize = 6;
-const IN_637: usize = 6;
-const OUT_637: usize = 1;
-fn aiur_fn_637(
-  inp: [G; IN_637],
+const INPUT_SIZE_618: usize = 6;
+const IN_618: usize = 6;
+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_637], ExecError> {
+) -> 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];
@@ -53446,15 +51987,15 @@ fn aiur_fn_637(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_637] = [__v_0];
-        record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_618] = [__v_0];
+        record.function_queries[618].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_428] = { let __args: [G; IN_428] = [__v_0, __v_8, __v_4, __v_5]; 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_414] = { let __args: [G; IN_414] = [__v_0, __v_8, __v_4, __v_5]; 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_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];
@@ -53463,19 +52004,19 @@ fn aiur_fn_637(
         let __v_13: G = __loaded[3];
         match __v_10.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_3]; 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 __v_14: G = __r_arr[0];
             let __v_15: G = G::from_u64(0);
-            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_12, __v_14, __v_15]; 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_392] = { let __args: [G; IN_392] = [__v_12, __v_14, __v_15]; 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 __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_637] = { let __args: [G; IN_637] = [__v_16, __v_18, __v_2, __v_20, __v_4, __v_5]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_16, __v_18, __v_2, __v_20, __v_4, __v_5]; 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_21: G = __r_arr[0];
-            let __ret: [G; OUT_637] = [__v_21];
-            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_618] = [__v_21];
+            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53487,15 +52028,15 @@ fn aiur_fn_637(
   })
 }
 
-const INPUT_SIZE_638: usize = 6;
-const IN_638: usize = 6;
-const OUT_638: usize = 1;
-fn aiur_fn_638(
-  inp: [G; IN_638],
+const INPUT_SIZE_619: usize = 6;
+const IN_619: usize = 6;
+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_638], ExecError> {
+) -> Result<[G; OUT_619], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53503,26 +52044,26 @@ fn aiur_fn_638(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_3]; 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_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_6, __v_1, __v_2, __v_7, __v_4, __v_5]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_6, __v_1, __v_2, __v_7, __v_4, __v_5]; 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_8: G = __r_arr[0];
-    let __ret: [G; OUT_638] = [__v_8];
-    record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_619] = [__v_8];
+    record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_639: usize = 21;
-const IN_639: usize = 21;
-const OUT_639: usize = 1;
-fn aiur_fn_639(
-  inp: [G; IN_639],
+const INPUT_SIZE_620: usize = 21;
+const IN_620: usize = 21;
+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_639], ExecError> {
+) -> 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];
@@ -53554,12 +52095,12 @@ fn aiur_fn_639(
         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_639] = [__v_26];
-        record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_620] = [__v_26];
+        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_18, __v_22]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_18, __v_22]; 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 __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];
@@ -53575,16 +52116,16 @@ fn aiur_fn_639(
         let __v_35: G = __loaded[10];
         match __v_25.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__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[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 __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__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[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_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_639] = { let __args: [G; IN_639] = [__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[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 __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__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[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_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_639] = [__v_41];
-            record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_620] = [__v_41];
+            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53599,15 +52140,15 @@ fn aiur_fn_639(
   })
 }
 
-const INPUT_SIZE_640: usize = 11;
-const IN_640: usize = 11;
-const OUT_640: usize = 1;
-fn aiur_fn_640(
-  inp: [G; IN_640],
+const INPUT_SIZE_621: usize = 11;
+const IN_621: usize = 11;
+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_640], 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];
@@ -53629,36 +52170,36 @@ fn aiur_fn_640(
         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_640] = [__v_16];
-        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_621] = [__v_16];
+        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_10]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_10]; 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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_14]; 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 __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_781] = { let __args: [G; IN_781] = [__v_2, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_12]; 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 __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_400] = { let __args: [G; IN_400] = [__v_18, __v_20, __v_21]; 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_386] = { let __args: [G; IN_386] = [__v_18, __v_20, __v_21]; 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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_22, __v_7, __v_8, __v_9]; 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_414] = { let __args: [G; IN_414] = [__v_22, __v_7, __v_8, __v_9]; 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_23]; 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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_23]; 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_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_24]; 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 __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_24]; 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 __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_26, __v_7]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_26, __v_7]; 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 __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_25, __v_27, __v_8, __v_9]; 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_414] = { let __args: [G; IN_414] = [__v_25, __v_27, __v_8, __v_9]; 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_24]; 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 __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);
@@ -53669,35 +52210,35 @@ fn aiur_fn_640(
         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_202] = { let __args: [G; IN_202] = [__v_28]; 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 __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_799] = { let __args: [G; IN_799] = [__v_40, __v_15]; 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_769] = { let __args: [G; IN_769] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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_414] = { let __args: [G; IN_414] = [__v_44, __v_41]; 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_400] = { let __args: [G; IN_400] = [__v_44, __v_41]; 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_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_544] = { let __args: [G; IN_544] = [__v_48, __v_29, __v_49]; 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 __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_48, __v_29, __v_49]; 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_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_545] = { let __args: [G; IN_545] = [__v_53, __v_24]; 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 __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_53, __v_24]; 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_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_640] = { let __args: [G; IN_640] = [__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[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_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_9, __v_57]; 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_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_640] = [__v_59];
-        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_621] = [__v_59];
+        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53707,15 +52248,15 @@ fn aiur_fn_640(
   })
 }
 
-const INPUT_SIZE_641: usize = 7;
-const IN_641: usize = 7;
-const OUT_641: usize = 0;
-fn aiur_fn_641(
-  inp: [G; IN_641],
+const INPUT_SIZE_622: usize = 7;
+const IN_622: usize = 7;
+const OUT_622: usize = 0;
+fn aiur_fn_622(
+  inp: [G; IN_622],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_641], ExecError> {
+) -> 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];
@@ -53757,19 +52298,19 @@ fn aiur_fn_641(
     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_130] = { let __args: [G; IN_130] = [__v_4, __v_39]; 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 __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() {
       1u64 => {
-        let __ret: [G; OUT_641] = [];
-        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_622] = [];
+        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_41: G = G::from_u64(0);
-        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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[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_641] = [];
-        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__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[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 __ret: [G; OUT_622] = [];
+        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53779,15 +52320,15 @@ fn aiur_fn_641(
   })
 }
 
-const INPUT_SIZE_642: usize = 9;
-const IN_642: usize = 9;
-const OUT_642: usize = 0;
-fn aiur_fn_642(
-  inp: [G; IN_642],
+const INPUT_SIZE_623: usize = 9;
+const IN_623: usize = 9;
+const OUT_623: usize = 0;
+fn aiur_fn_623(
+  inp: [G; IN_623],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_642], 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];
@@ -53804,8 +52345,8 @@ fn aiur_fn_642(
     let __v_11: G = __loaded[2];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_642] = [];
-        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_623] = [];
+        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -53823,7 +52364,7 @@ fn aiur_fn_642(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_19, __v_4]; 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 __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));
@@ -53832,23 +52373,23 @@ fn aiur_fn_642(
             let __v_28: G = (__v_23 * __v_27);
             match __v_28.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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 __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_1, __v_14, __v_2, __v_6, __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_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_508] = { let __args: [G; IN_508] = [__v_1, __v_29, __v_32, __v_6, __v_7]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_29, __v_32, __v_6, __v_7]; 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_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_508] = { let __args: [G; IN_508] = [__v_14, __v_34, __v_37, __v_6, __v_7]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_14, __v_34, __v_37, __v_6, __v_7]; 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_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_229] = { let __args: [G; IN_229] = [__v_33, __v_38]; 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 __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) {
@@ -53856,17 +52397,17 @@ fn aiur_fn_642(
                 }
                 let __v_41: G = G::from_u64(1);
                 let __v_42: G = (__v_8 + __v_41);
-                let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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[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));
+                let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__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[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 __ret: [G; OUT_623] = [];
+                record.function_queries[623].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_642] = { let __args: [G; IN_642] = [__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[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));
+                let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__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[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 __ret: [G; OUT_623] = [];
+                record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -53877,9 +52418,9 @@ fn aiur_fn_642(
           _ => {
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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[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));
+            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__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[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 __ret: [G; OUT_623] = [];
+            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -53891,15 +52432,15 @@ fn aiur_fn_642(
   })
 }
 
-const INPUT_SIZE_643: usize = 5;
-const IN_643: usize = 5;
-const OUT_643: usize = 0;
-fn aiur_fn_643(
-  inp: [G; IN_643],
+const INPUT_SIZE_624: usize = 5;
+const IN_624: usize = 5;
+const OUT_624: usize = 0;
+fn aiur_fn_624(
+  inp: [G; IN_624],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_643], 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];
@@ -53909,22 +52450,22 @@ fn aiur_fn_643(
     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_644] = { let __args: [G; IN_644] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; 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_643] = [];
-    record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; 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 __ret: [G; OUT_624] = [];
+    record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_644: usize = 6;
-const IN_644: usize = 6;
-const OUT_644: usize = 0;
-fn aiur_fn_644(
-  inp: [G; IN_644],
+const INPUT_SIZE_625: usize = 6;
+const IN_625: usize = 6;
+const OUT_625: usize = 0;
+fn aiur_fn_625(
+  inp: [G; IN_625],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_644], 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];
@@ -53934,8 +52475,8 @@ fn aiur_fn_644(
     let __v_5: G = inp[5];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_644] = [];
-        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_625] = [];
+        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53953,7 +52494,7 @@ fn aiur_fn_644(
             let __v_13: G = __loaded[3];
             match __v_10.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_11, __v_3, __v_4, __v_5]; 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 __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_11, __v_3, __v_4, __v_5]; 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_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 } };
@@ -53963,9 +52504,9 @@ fn aiur_fn_644(
                 }
                 let __v_18: G = G::from_u64(1);
                 let __v_19: G = (__v_2 - __v_18);
-                let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_8, __v_12, __v_19, __v_16, __v_4, __v_5]; 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_644] = [];
-                record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_8, __v_12, __v_19, __v_16, __v_4, __v_5]; 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 __ret: [G; OUT_625] = [];
+                record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -53982,15 +52523,15 @@ fn aiur_fn_644(
   })
 }
 
-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_626: usize = 2;
+const IN_626: usize = 2;
+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_645], 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];
@@ -53998,8 +52539,8 @@ fn aiur_fn_645(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_645] = [__v_3];
-        record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_626] = [__v_3];
+        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -54007,14 +52548,14 @@ fn aiur_fn_645(
         match __v_3.as_canonical_u64() {
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_645] = [__v_4];
-            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_626] = [__v_4];
+            record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_645] = [__v_4];
-            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_626] = [__v_4];
+            record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -54026,132 +52567,96 @@ fn aiur_fn_645(
   })
 }
 
-const INPUT_SIZE_646: usize = 2;
-const IN_646: usize = 2;
-const OUT_646: usize = 1;
-fn aiur_fn_646(
-  inp: [G; IN_646],
+const INPUT_SIZE_627: usize = 2;
+const IN_627: usize = 2;
+const OUT_627: usize = 1;
+fn aiur_fn_627(
+  inp: [G; IN_627],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_646], ExecError> {
+) -> Result<[G; OUT_627], 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() {
       1u64 => {
-        let __ret: [G; OUT_646] = [__v_1];
-        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_627] = [__v_1];
+        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_646] = [__v_0];
-        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_627] = [__v_0];
+        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_647: usize = 0;
-const IN_647: usize = 0;
-const OUT_647: usize = 2;
-fn aiur_fn_647(
-  inp: [G; IN_647],
+const INPUT_SIZE_628: usize = 0;
+const IN_628: usize = 0;
+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_647], ExecError> {
+) -> Result<[G; OUT_628], 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_647] = [__v_0, __v_1];
-    record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_648: usize = 0;
-const IN_648: usize = 0;
-const OUT_648: usize = 2;
-fn aiur_fn_648(
-  inp: [G; IN_648],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_648], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(0);
-    let __ret: [G; OUT_648] = [__v_0, __v_1];
-    record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_628] = [__v_0, __v_1];
+    record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_649: usize = 0;
-const IN_649: usize = 0;
-const OUT_649: usize = 2;
-fn aiur_fn_649(
-  inp: [G; IN_649],
+const INPUT_SIZE_629: usize = 0;
+const IN_629: usize = 0;
+const OUT_629: usize = 2;
+fn aiur_fn_629(
+  inp: [G; IN_629],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_649], ExecError> {
+) -> Result<[G; OUT_629], 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_649] = [__v_0, __v_1];
-    record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_629] = [__v_0, __v_1];
+    record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_650: usize = 0;
-const IN_650: usize = 0;
-const OUT_650: usize = 2;
-fn aiur_fn_650(
-  inp: [G; IN_650],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_650], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(1);
-    let __v_1: G = G::from_u64(0);
-    let __ret: [G; OUT_650] = [__v_0, __v_1];
-    record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_651: usize = 0;
-const IN_651: usize = 0;
-const OUT_651: usize = 2;
-fn aiur_fn_651(
-  inp: [G; IN_651],
+const INPUT_SIZE_630: usize = 0;
+const IN_630: usize = 0;
+const OUT_630: usize = 2;
+fn aiur_fn_630(
+  inp: [G; IN_630],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_651], ExecError> {
+) -> Result<[G; OUT_630], 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_651] = [__v_0, __v_1];
-    record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_630] = [__v_0, __v_1];
+    record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_652: usize = 4;
-const IN_652: usize = 4;
-const OUT_652: usize = 2;
-fn aiur_fn_652(
-  inp: [G; IN_652],
+const INPUT_SIZE_631: usize = 4;
+const IN_631: usize = 4;
+const OUT_631: usize = 2;
+fn aiur_fn_631(
+  inp: [G; IN_631],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_652], 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];
@@ -54160,46 +52665,46 @@ fn aiur_fn_652(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_4: G = (__v_1 * __v_3);
-        let __ret: [G; OUT_652] = [__v_2, __v_4];
-        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_631] = [__v_2, __v_4];
+        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_652] = [__v_0, __v_1];
-        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_631] = [__v_0, __v_1];
+        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_653: usize = 1;
-const IN_653: usize = 1;
-const OUT_653: usize = 2;
-fn aiur_fn_653(
-  inp: [G; IN_653],
+const INPUT_SIZE_632: usize = 1;
+const IN_632: usize = 1;
+const OUT_632: usize = 2;
+fn aiur_fn_632(
+  inp: [G; IN_632],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_653], ExecError> {
+) -> Result<[G; OUT_632], 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_653] = [__v_0, __v_1];
-    record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_632] = [__v_0, __v_1];
+    record.function_queries[632].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_633: usize = 2;
+const IN_633: usize = 2;
+const OUT_633: usize = 1;
+fn aiur_fn_633(
+  inp: [G; IN_633],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_654], 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];
@@ -54211,8 +52716,8 @@ fn aiur_fn_654(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_654] = [__v_6];
-        record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_633] = [__v_6];
+        record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -54221,15 +52726,15 @@ fn aiur_fn_654(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_7 + __v_4);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_633] = [__v_8];
+            record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __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 __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0, __v_5]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_654] = [__v_7];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_633] = [__v_7];
+            record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54241,15 +52746,15 @@ fn aiur_fn_654(
   })
 }
 
-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_634: usize = 2;
+const IN_634: usize = 2;
+const OUT_634: usize = 1;
+fn aiur_fn_634(
+  inp: [G; IN_634],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_655], 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];
@@ -54319,51 +52824,51 @@ fn aiur_fn_655(
     let __v_63: G = __loaded[29];
     let __v_64: G = __loaded[30];
     let __v_65: G = __loaded[31];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_66: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_72: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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[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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_72, __v_73]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_72, __v_73]; 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_74: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_71, __v_74]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_71, __v_74]; 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_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_70, __v_75]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_70, __v_75]; 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_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_69, __v_76]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_69, __v_76]; 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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_68, __v_77]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_68, __v_77]; 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_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_67, __v_78]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_67, __v_78]; 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_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_66, __v_79]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_66, __v_79]; 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_80: G = __r_arr[0];
-    let __ret: [G; OUT_655] = [__v_80];
-    record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_634] = [__v_80];
+    record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_656: usize = 8;
-const IN_656: usize = 8;
-const OUT_656: usize = 1;
-fn aiur_fn_656(
-  inp: [G; IN_656],
+const INPUT_SIZE_635: usize = 8;
+const IN_635: usize = 8;
+const OUT_635: usize = 1;
+fn aiur_fn_635(
+  inp: [G; IN_635],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_656], 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];
@@ -54391,23 +52896,23 @@ fn aiur_fn_656(
     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_645] = { let __args: [G; IN_645] = [__v_16, __v_25]; 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_626] = { let __args: [G; IN_626] = [__v_16, __v_25]; 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_26: G = __r_arr[0];
-    let __ret: [G; OUT_656] = [__v_26];
-    record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_635] = [__v_26];
+    record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_657: usize = 4;
-const IN_657: usize = 4;
-const OUT_657: usize = 2;
-fn aiur_fn_657(
-  inp: [G; IN_657],
+const INPUT_SIZE_636: usize = 4;
+const IN_636: usize = 4;
+const OUT_636: usize = 2;
+fn aiur_fn_636(
+  inp: [G; IN_636],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_657], 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];
@@ -54416,41 +52921,41 @@ fn aiur_fn_657(
     let __v_4: G = (__v_0 - __v_1);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_657] = [__v_5, __v_6];
-        record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_636] = [__v_5, __v_6];
+        record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_2]; 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 __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0, __v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_1, __v_2]; 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_6: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_0]; 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 __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_1]; 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 __v_8: G = __r_arr[0];
-                let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_7, __v_8]; 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 __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_7, __v_8]; 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_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_9]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_9]; 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_10: G = __r_arr[0];
                 let __v_11: G = __r_arr[1];
-                let __ret: [G; OUT_657] = [__v_10, __v_11];
-                record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_636] = [__v_10, __v_11];
+                record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_657] = [__v_7, __v_8];
-                record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_636] = [__v_7, __v_8];
+                record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -54458,19 +52963,19 @@ fn aiur_fn_657(
           _ => {
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_657] = [__v_7, __v_8];
-                record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_636] = [__v_7, __v_8];
+                record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_6]; 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_626] = { let __args: [G; IN_626] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_657] = [__v_7, __v_8];
-                record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_636] = [__v_7, __v_8];
+                record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -54481,15 +52986,15 @@ fn aiur_fn_657(
   })
 }
 
-const INPUT_SIZE_658: usize = 2;
-const IN_658: usize = 2;
-const OUT_658: usize = 1;
-fn aiur_fn_658(
-  inp: [G; IN_658],
+const INPUT_SIZE_637: usize = 2;
+const IN_637: usize = 2;
+const OUT_637: usize = 1;
+fn aiur_fn_637(
+  inp: [G; IN_637],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_658], 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];
@@ -54506,14 +53011,14 @@ fn aiur_fn_658(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54526,21 +53031,21 @@ fn aiur_fn_658(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_3, __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_8: G = __r_arr[0];
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54553,31 +53058,31 @@ fn aiur_fn_658(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_3, __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_658] = [__v_10];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_10];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54590,37 +53095,37 @@ fn aiur_fn_658(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_3, __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_658] = [__v_10];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_10];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -54635,16 +53140,16 @@ fn aiur_fn_658(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_6]; 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_626] = { let __args: [G; IN_626] = [__v_3, __v_6]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_658] = [__v_8];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_8];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54656,15 +53161,15 @@ fn aiur_fn_658(
   })
 }
 
-const INPUT_SIZE_659: usize = 2;
-const IN_659: usize = 2;
-const OUT_659: usize = 1;
-fn aiur_fn_659(
-  inp: [G; IN_659],
+const INPUT_SIZE_638: usize = 2;
+const IN_638: usize = 2;
+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_659], 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];
@@ -54681,14 +53186,14 @@ fn aiur_fn_659(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_659] = [__v_8];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_638] = [__v_8];
+            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_659] = [__v_8];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_638] = [__v_8];
+            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54701,19 +53206,19 @@ fn aiur_fn_659(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_659] = [__v_8];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_638] = [__v_8];
+            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_3, __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_4, __v_7]; 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_638] = { let __args: [G; IN_638] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_659] = [__v_10];
-            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_638] = [__v_10];
+            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -54728,38 +53233,38 @@ fn aiur_fn_659(
   })
 }
 
-const INPUT_SIZE_660: usize = 2;
-const IN_660: usize = 2;
-const OUT_660: usize = 2;
-fn aiur_fn_660(
-  inp: [G; IN_660],
+const INPUT_SIZE_639: usize = 2;
+const IN_639: usize = 2;
+const OUT_639: usize = 2;
+fn aiur_fn_639(
+  inp: [G; IN_639],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_660], 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 __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1]; 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_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_2]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_660] = [__v_3, __v_4];
-    record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_639] = [__v_3, __v_4];
+    record.function_queries[639].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_640: usize = 2;
+const IN_640: usize = 2;
+const OUT_640: usize = 1;
+fn aiur_fn_640(
+  inp: [G; IN_640],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_661], 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];
@@ -54767,8 +53272,8 @@ fn aiur_fn_661(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_661] = [__v_3];
-        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_640] = [__v_3];
+        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -54782,25 +53287,25 @@ fn aiur_fn_661(
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
-        let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__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[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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__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[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_11: G = __r_arr[0];
-        let __ret: [G; OUT_661] = [__v_11];
-        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_640] = [__v_11];
+        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_662: usize = 8;
-const IN_662: usize = 8;
-const OUT_662: usize = 1;
-fn aiur_fn_662(
-  inp: [G; IN_662],
+const INPUT_SIZE_641: usize = 8;
+const IN_641: usize = 8;
+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_662], 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];
@@ -54814,16 +53319,16 @@ fn aiur_fn_662(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_5]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_5]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54832,21 +53337,21 @@ fn aiur_fn_662(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_1, __v_5]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54855,31 +53360,31 @@ fn aiur_fn_662(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_6]; 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_638] = { let __args: [G; IN_638] = [__v_2, __v_6]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_5]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_5]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_10];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_10];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54888,37 +53393,37 @@ fn aiur_fn_662(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_10];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_10];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54927,43 +53432,43 @@ fn aiur_fn_662(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_10];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_10];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54972,49 +53477,49 @@ fn aiur_fn_662(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_10];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_10];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55023,59 +53528,59 @@ fn aiur_fn_662(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_1, __v_5]; 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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_10]; 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_11]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_12];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_12];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55084,21 +53589,21 @@ fn aiur_fn_662(
         match __v_4.as_canonical_u64() {
           8u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_2, __v_5, __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_644] = { let __args: [G; IN_644] = [__v_1, __v_2, __v_5, __v_6]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55106,24 +53611,24 @@ fn aiur_fn_662(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_5]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_5]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_2, __v_6]; 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_626] = { let __args: [G; IN_626] = [__v_2, __v_6]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_3, __v_7]; 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 __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_10]; 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_11]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_12];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_12];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_662] = [__v_8];
-            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_641] = [__v_8];
+            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55135,15 +53640,15 @@ fn aiur_fn_662(
   })
 }
 
-const INPUT_SIZE_663: usize = 4;
-const IN_663: usize = 4;
-const OUT_663: usize = 2;
-fn aiur_fn_663(
-  inp: [G; IN_663],
+const INPUT_SIZE_642: usize = 4;
+const IN_642: usize = 4;
+const OUT_642: usize = 2;
+fn aiur_fn_642(
+  inp: [G; IN_642],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_663], 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];
@@ -55152,11 +53657,11 @@ fn aiur_fn_663(
     let __v_4: G = (__v_0 - __v_1);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_663] = [__v_5, __v_6];
-        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_642] = [__v_5, __v_6];
+        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -55170,26 +53675,26 @@ fn aiur_fn_663(
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
         let __v_12: G = __loaded[3];
-        let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__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[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 __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__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[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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_663] = [__v_13, __v_14];
-        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_642] = [__v_13, __v_14];
+        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_664: usize = 10;
-const IN_664: usize = 10;
-const OUT_664: usize = 2;
-fn aiur_fn_664(
-  inp: [G; IN_664],
+const INPUT_SIZE_643: usize = 10;
+const IN_643: usize = 10;
+const OUT_643: usize = 2;
+fn aiur_fn_643(
+  inp: [G; IN_643],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_664], 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];
@@ -55205,21 +53710,21 @@ fn aiur_fn_664(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_5]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_5]; 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_10: G = __r_arr[0];
-            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)? } };
+            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_11, __v_12];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_11, __v_12];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55227,29 +53732,29 @@ fn aiur_fn_664(
       1u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_1, __v_5]; 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_10: G = __r_arr[0];
-            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)? } };
+            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_11, __v_12];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_11, __v_12];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55257,41 +53762,41 @@ fn aiur_fn_664(
       2u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_2, __v_6]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_5, __v_8, __v_9]; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_1, __v_5, __v_8, __v_9]; 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 __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10, __v_11, __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_631] = { let __args: [G; IN_631] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_14, __v_15];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_14, __v_15];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55299,49 +53804,49 @@ fn aiur_fn_664(
       3u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_1, __v_5, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_6, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10, __v_11, __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_631] = { let __args: [G; IN_631] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_14, __v_15];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_14, __v_15];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55349,57 +53854,57 @@ fn aiur_fn_664(
       4u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_1, __v_5, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_6, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10, __v_11, __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_631] = { let __args: [G; IN_631] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_14, __v_15];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_14, __v_15];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55407,65 +53912,65 @@ fn aiur_fn_664(
       5u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_1, __v_5, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_6, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10, __v_11, __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_631] = { let __args: [G; IN_631] = [__v_10, __v_11, __v_12, __v_13]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_14, __v_15];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_14, __v_15];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55473,79 +53978,79 @@ fn aiur_fn_664(
       6u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_1, __v_5, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_6, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_6, __v_8, __v_9]; 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3, __v_7, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_3, __v_7, __v_8, __v_9]; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_12, __v_13, __v_14, __v_15]; 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_631] = { let __args: [G; IN_631] = [__v_12, __v_13, __v_14, __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 __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10, __v_11, __v_16, __v_17]; 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_631] = { let __args: [G; IN_631] = [__v_10, __v_11, __v_16, __v_17]; 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_18, __v_19];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_18, __v_19];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55553,29 +54058,29 @@ fn aiur_fn_664(
       7u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_2, __v_5, __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_644] = { let __args: [G; IN_644] = [__v_1, __v_2, __v_5, __v_6]; 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_10: G = __r_arr[0];
-            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)? } };
+            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_10]; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_11, __v_12];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_11, __v_12];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55583,33 +54088,33 @@ fn aiur_fn_664(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_5, __v_8, __v_9]; 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 __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_1, __v_5, __v_8, __v_9]; 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_2, __v_6]; 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_626] = { let __args: [G; IN_626] = [__v_2, __v_6]; 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_12]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_12]; 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3, __v_7, __v_8, __v_9]; 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_642] = { let __args: [G; IN_642] = [__v_3, __v_7, __v_8, __v_9]; 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_14, __v_15, __v_16]; 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_631] = { let __args: [G; IN_631] = [__v_13, __v_14, __v_15, __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 __v_18: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_10, __v_11, __v_17, __v_18]; 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_631] = { let __args: [G; IN_631] = [__v_10, __v_11, __v_17, __v_18]; 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_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_664] = [__v_19, __v_20];
-            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_643] = [__v_19, __v_20];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_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 __ret: [G; OUT_643] = [__v_10, __v_11];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55621,15 +54126,15 @@ fn aiur_fn_664(
   })
 }
 
-const INPUT_SIZE_665: usize = 4;
-const IN_665: usize = 4;
-const OUT_665: usize = 1;
-fn aiur_fn_665(
-  inp: [G; IN_665],
+const INPUT_SIZE_644: usize = 4;
+const IN_644: usize = 4;
+const OUT_644: usize = 1;
+fn aiur_fn_644(
+  inp: [G; IN_644],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_665], 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];
@@ -55639,16 +54144,16 @@ fn aiur_fn_665(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_3]; 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_4: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_4];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_644] = [__v_4];
+            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_665] = [__v_4];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_644] = [__v_4];
+            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55660,15 +54165,15 @@ fn aiur_fn_665(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_4];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_644] = [__v_4];
+            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_1, __v_3]; 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_4: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_4];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_644] = [__v_4];
+            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55683,54 +54188,54 @@ 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_645: usize = 2;
+const IN_645: usize = 2;
+const OUT_645: usize = 1;
+fn aiur_fn_645(
+  inp: [G; IN_645],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_666], 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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; 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 __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 __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; 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 __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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_2]; 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 __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_3]; 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 __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_3]; 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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_5]; 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_626] = { let __args: [G; IN_626] = [__v_4, __v_5]; 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_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_2, __v_3]; 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 __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_2, __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_666] = [__v_7];
-        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_645] = [__v_7];
+        record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_666] = [__v_6];
-        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_645] = [__v_6];
+        record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_667: usize = 2;
-const IN_667: usize = 2;
-const OUT_667: usize = 1;
-fn aiur_fn_667(
-  inp: [G; IN_667],
+const INPUT_SIZE_646: usize = 2;
+const IN_646: usize = 2;
+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_667], ExecError> {
+) -> Result<[G; OUT_646], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55748,8 +54253,8 @@ fn aiur_fn_667(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_667] = [__v_12];
-        record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_646] = [__v_12];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -55766,14 +54271,14 @@ fn aiur_fn_667(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_11, __v_21]; 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 __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_11, __v_21]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__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[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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__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[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];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-            let __ret: [G; OUT_667] = [__v_24];
-            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_646] = [__v_24];
+            record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55788,15 +54293,15 @@ fn aiur_fn_667(
   })
 }
 
-const INPUT_SIZE_668: usize = 16;
-const IN_668: usize = 16;
-const OUT_668: usize = 1;
-fn aiur_fn_668(
-  inp: [G; IN_668],
+const INPUT_SIZE_647: usize = 16;
+const IN_647: usize = 16;
+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_668], 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];
@@ -55814,51 +54319,51 @@ fn aiur_fn_668(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_7, __v_15]; 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_626] = { let __args: [G; IN_626] = [__v_7, __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_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_14]; 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_626] = { let __args: [G; IN_626] = [__v_6, __v_14]; 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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_13]; 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_626] = { let __args: [G; IN_626] = [__v_5, __v_13]; 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_4, __v_12]; 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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_11]; 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_626] = { let __args: [G; IN_626] = [__v_3, __v_11]; 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_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_2, __v_10]; 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_626] = { let __args: [G; IN_626] = [__v_2, __v_10]; 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_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_9]; 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_626] = { let __args: [G; IN_626] = [__v_1, __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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_8]; 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_626] = { let __args: [G; IN_626] = [__v_0, __v_8]; 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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_23]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_21, __v_24]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_21, __v_24]; 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_20, __v_25]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_20, __v_25]; 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_19, __v_26]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_19, __v_26]; 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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_18, __v_27]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_18, __v_27]; 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_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_17, __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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_17, __v_28]; 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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_16, __v_29]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_16, __v_29]; 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_30: G = __r_arr[0];
-    let __ret: [G; OUT_668] = [__v_30];
-    record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_647] = [__v_30];
+    record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_669: usize = 2;
-const IN_669: usize = 2;
-const OUT_669: usize = 1;
-fn aiur_fn_669(
-  inp: [G; IN_669],
+const INPUT_SIZE_648: usize = 2;
+const IN_648: usize = 2;
+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_669], 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];
@@ -55875,14 +54380,14 @@ fn aiur_fn_669(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].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_648] = [__v_8];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55895,19 +54400,19 @@ fn aiur_fn_669(
         match __v_5.as_canonical_u64() {
           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));
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_6]; 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_626] = { let __args: [G; IN_626] = [__v_3, __v_6]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9]; 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 __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_10];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_648] = [__v_10];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55922,129 +54427,15 @@ fn aiur_fn_669(
   })
 }
 
-const INPUT_SIZE_670: usize = 6;
-const IN_670: usize = 6;
-const OUT_670: usize = 1;
-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];
-    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() {
-      _ => {
-        match __v_3.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_4]; 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __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 __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_6, __v_7]; 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_670] = [__v_8];
-            record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_671: usize = 2;
-const IN_671: usize = 2;
-const OUT_671: usize = 1;
-fn aiur_fn_671(
-  inp: [G; IN_671],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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 __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 __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_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];
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __v_12: G = G::from_u64(1);
-            let __ret: [G; OUT_671] = [__v_12];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_12: G = G::from_u64(0);
-            let __ret: [G; OUT_671] = [__v_12];
-            record.function_queries[671].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_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];
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __v_12: G = G::from_u64(2);
-            let __ret: [G; OUT_671] = [__v_12];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; 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 __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_6, __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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_12, __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_14: G = __r_arr[0];
-            let __ret: [G; OUT_671] = [__v_14];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_672: usize = 8;
-const IN_672: usize = 8;
-const OUT_672: usize = 2;
-fn aiur_fn_672(
-  inp: [G; IN_672],
+const INPUT_SIZE_649: usize = 8;
+const IN_649: usize = 8;
+const OUT_649: usize = 2;
+fn aiur_fn_649(
+  inp: [G; IN_649],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_672], 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];
@@ -56058,19 +54449,19 @@ fn aiur_fn_672(
       _ => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_4]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_4]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_8]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8]; 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_5, __v_6, __v_7]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_5, __v_6, __v_7]; 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 __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_9, __v_10, __v_11, __v_12]; 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_631] = { let __args: [G; IN_631] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_672] = [__v_13, __v_14];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_649] = [__v_13, __v_14];
+            record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -56079,15 +54470,15 @@ fn aiur_fn_672(
   })
 }
 
-const INPUT_SIZE_673: usize = 4;
-const IN_673: usize = 4;
-const OUT_673: usize = 2;
-fn aiur_fn_673(
-  inp: [G; IN_673],
+const INPUT_SIZE_650: usize = 4;
+const IN_650: usize = 4;
+const OUT_650: usize = 2;
+fn aiur_fn_650(
+  inp: [G; IN_650],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_673], 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];
@@ -56109,19 +54500,19 @@ fn aiur_fn_673(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_673] = [__v_14, __v_15];
-            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_650] = [__v_14, __v_15];
+            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = []; 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 __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = []; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_673] = [__v_14, __v_15];
-            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_650] = [__v_14, __v_15];
+            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -56135,25 +54526,25 @@ fn aiur_fn_673(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = []; 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 __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = []; 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_673] = [__v_14, __v_15];
-            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_650] = [__v_14, __v_15];
+            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__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[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 __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__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[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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_8, __v_13, __v_2, __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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_8, __v_13, __v_2, __v_3]; 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_15, __v_16, __v_17]; 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_631] = { let __args: [G; IN_631] = [__v_14, __v_15, __v_16, __v_17]; 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_673] = [__v_18, __v_19];
-            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_650] = [__v_18, __v_19];
+            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56168,15 +54559,15 @@ fn aiur_fn_673(
   })
 }
 
-const INPUT_SIZE_674: usize = 11;
-const IN_674: usize = 11;
-const OUT_674: usize = 1;
-fn aiur_fn_674(
-  inp: [G; IN_674],
+const INPUT_SIZE_651: usize = 11;
+const IN_651: usize = 11;
+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_674], 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];
@@ -56192,50 +54583,50 @@ fn aiur_fn_674(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_11: G = G::from_u64(1);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_11: G = G::from_u64(2);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_11: G = G::from_u64(3);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_11: G = G::from_u64(5);
-        let __ret: [G; OUT_674] = [__v_11];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_651] = [__v_11];
+        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -56245,330 +54636,15 @@ fn aiur_fn_674(
   })
 }
 
-const INPUT_SIZE_675: usize = 22;
-const IN_675: usize = 22;
-const OUT_675: usize = 1;
-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 __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 __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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_674] = { let __args: [G; IN_674] = [__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[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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-    match __v_24.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__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]; 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_25: G = __r_arr[0];
-        let __ret: [G; OUT_675] = [__v_25];
-        record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __ret: [G; OUT_675] = [__v_24];
-        record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_676: usize = 22;
-const IN_676: usize = 22;
-const OUT_676: usize = 1;
-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 __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];
-    match __v_0.as_canonical_u64() {
-      1u64 => {
-        match __v_11.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_3, __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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_23, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_25]; 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_26: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_26];
-            record.function_queries[676].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_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_3, __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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_23, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_25]; 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_26: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_26];
-            record.function_queries[676].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_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_3, __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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_25]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_23, __v_26]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_27]; 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_28: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_28];
-            record.function_queries[676].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_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_24];
-            record.function_queries[676].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_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_14]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_23, __v_24]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_25]; 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_26: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_26];
-            record.function_queries[676].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() {
-          5u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_17]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_14]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_5]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_16]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_26, __v_27]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_28, __v_29]; 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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_25, __v_30]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_31]; 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_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_23, __v_32]; 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_33]; 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_34: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_34];
-            record.function_queries[676].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_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_16]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_17]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_25, __v_26]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_27]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_23, __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_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __v_29]; 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_30: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_30];
-            record.function_queries[676].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_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_14]; 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_16]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_17]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_8, __v_19]; 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_2, __v_13]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_7, __v_18]; 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_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_28, __v_29]; 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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_27, __v_30]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_26, __v_31]; 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_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_25, __v_32]; 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_33]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_23, __v_34]; 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_35: G = __r_arr[0];
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_22, __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_36: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_36];
-            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_677: usize = 25;
-const IN_677: usize = 25;
-const OUT_677: usize = 2;
-fn aiur_fn_677(
-  inp: [G; IN_677],
+const INPUT_SIZE_652: usize = 25;
+const IN_652: usize = 25;
+const OUT_652: usize = 2;
+fn aiur_fn_652(
+  inp: [G; IN_652],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_677], 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];
@@ -56595,42 +54671,42 @@ fn aiur_fn_677(
     let __v_22: G = inp[22];
     let __v_23: G = inp[23];
     let __v_24: G = inp[24];
-    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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 __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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 __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_25, __v_26]; 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_626] = { let __args: [G; IN_626] = [__v_25, __v_26]; 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_27: G = __r_arr[0];
     match __v_27.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__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[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 __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__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[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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_677] = [__v_28, __v_29];
-        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_652] = [__v_28, __v_29];
+        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_27]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_27]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_677] = [__v_28, __v_29];
-        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_652] = [__v_28, __v_29];
+        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_678: usize = 25;
-const IN_678: usize = 25;
-const OUT_678: usize = 2;
-fn aiur_fn_678(
-  inp: [G; IN_678],
+const INPUT_SIZE_653: usize = 25;
+const IN_653: usize = 25;
+const OUT_653: usize = 2;
+fn aiur_fn_653(
+  inp: [G; IN_653],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_678], ExecError> {
+) -> Result<[G; OUT_653], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56661,25 +54737,25 @@ fn aiur_fn_678(
       1u64 => {
         match __v_11.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3, __v_14, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_3, __v_14, __v_22, __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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_28, __v_29, __v_30, __v_31]; 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_631] = { let __args: [G; IN_631] = [__v_28, __v_29, __v_30, __v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_32, __v_33]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_32, __v_33]; 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_34, __v_35];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_34, __v_35];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56690,25 +54766,25 @@ fn aiur_fn_678(
       2u64 => {
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3, __v_14, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_3, __v_14, __v_22, __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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_28, __v_29, __v_30, __v_31]; 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_631] = { let __args: [G; IN_631] = [__v_28, __v_29, __v_30, __v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_32, __v_33]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_32, __v_33]; 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_34, __v_35];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_34, __v_35];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56719,33 +54795,33 @@ fn aiur_fn_678(
       3u64 => {
         match __v_11.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3, __v_14, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_3, __v_14, __v_22, __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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_626] = { let __args: [G; IN_626] = [__v_4, __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_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_32]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_32]; 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_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_30, __v_31, __v_33, __v_34]; 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_631] = { let __args: [G; IN_631] = [__v_30, __v_31, __v_33, __v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_28, __v_29, __v_35, __v_36]; 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_631] = { let __args: [G; IN_631] = [__v_28, __v_29, __v_35, __v_36]; 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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_37, __v_38]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_37, __v_38]; 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_39, __v_40];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_39, __v_40];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56756,19 +54832,19 @@ fn aiur_fn_678(
       4u64 => {
         match __v_11.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_28, __v_29]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_28, __v_29]; 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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_30, __v_31];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_30, __v_31];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56779,27 +54855,27 @@ fn aiur_fn_678(
       0u64 => {
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_14]; 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_626] = { let __args: [G; IN_626] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_30]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_30]; 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_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_28, __v_29, __v_31, __v_32]; 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_631] = { let __args: [G; IN_631] = [__v_28, __v_29, __v_31, __v_32]; 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_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_33, __v_34]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_33, __v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_35, __v_36];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_35, __v_36];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56810,61 +54886,61 @@ fn aiur_fn_678(
       5u64 => {
         match __v_11.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_17]; 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_626] = { let __args: [G; IN_626] = [__v_6, __v_17]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_28]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_28]; 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_14]; 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_626] = { let __args: [G; IN_626] = [__v_3, __v_14]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_31]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_626] = { let __args: [G; IN_626] = [__v_4, __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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_34]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_5]; 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 __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_200] = { let __args: [G; IN_200] = [__v_16]; 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 __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_645] = { let __args: [G; IN_645] = [__v_37, __v_38]; 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_626] = { let __args: [G; IN_626] = [__v_37, __v_38]; 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_39: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_39]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_39]; 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_40: G = __r_arr[0];
             let __v_41: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_16, __v_22, __v_23, __v_24]; 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 __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_16, __v_22, __v_23, __v_24]; 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_44: G = __r_arr[0];
             let __v_45: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_42, __v_43, __v_44, __v_45]; 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_631] = { let __args: [G; IN_631] = [__v_42, __v_43, __v_44, __v_45]; 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_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_40, __v_41, __v_46, __v_47]; 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_631] = { let __args: [G; IN_631] = [__v_40, __v_41, __v_46, __v_47]; 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_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_35, __v_36, __v_48, __v_49]; 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_631] = { let __args: [G; IN_631] = [__v_35, __v_36, __v_48, __v_49]; 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_50: G = __r_arr[0];
             let __v_51: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_32, __v_33, __v_50, __v_51]; 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_631] = { let __args: [G; IN_631] = [__v_32, __v_33, __v_50, __v_51]; 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_29, __v_30, __v_52, __v_53]; 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_631] = { let __args: [G; IN_631] = [__v_29, __v_30, __v_52, __v_53]; 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_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_54, __v_55]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_54, __v_55]; 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_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_56, __v_57];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_56, __v_57];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56875,43 +54951,43 @@ fn aiur_fn_678(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_626] = { let __args: [G; IN_626] = [__v_4, __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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_28]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_28]; 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_16]; 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_626] = { let __args: [G; IN_626] = [__v_5, __v_16]; 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_31]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_17]; 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_626] = { let __args: [G; IN_626] = [__v_6, __v_17]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_34]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_35, __v_36, __v_37, __v_38]; 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_631] = { let __args: [G; IN_631] = [__v_35, __v_36, __v_37, __v_38]; 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_32, __v_33, __v_39, __v_40]; 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_631] = { let __args: [G; IN_631] = [__v_32, __v_33, __v_39, __v_40]; 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_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_29, __v_30, __v_41, __v_42]; 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_631] = { let __args: [G; IN_631] = [__v_29, __v_30, __v_41, __v_42]; 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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_43, __v_44]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_43, __v_44]; 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_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_45, __v_46];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_45, __v_46];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56922,65 +54998,65 @@ fn aiur_fn_678(
       7u64 => {
         match __v_11.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_25]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_14]; 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_626] = { let __args: [G; IN_626] = [__v_3, __v_14]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_28]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_28]; 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_626] = { let __args: [G; IN_626] = [__v_4, __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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_31]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_31]; 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_16]; 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_626] = { let __args: [G; IN_626] = [__v_5, __v_16]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_34]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_34]; 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_17]; 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_626] = { let __args: [G; IN_626] = [__v_6, __v_17]; 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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_37]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_37]; 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_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_8, __v_19]; 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_626] = { let __args: [G; IN_626] = [__v_8, __v_19]; 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_40: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_40]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_40]; 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_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_24]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_7, __v_18, __v_22, __v_24]; 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 __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_18, __v_22, __v_24]; 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_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_43, __v_44, __v_45, __v_46]; 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_631] = { let __args: [G; IN_631] = [__v_43, __v_44, __v_45, __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 = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_41, __v_42, __v_47, __v_48]; 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_631] = { let __args: [G; IN_631] = [__v_41, __v_42, __v_47, __v_48]; 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_49: G = __r_arr[0];
             let __v_50: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_38, __v_39, __v_49, __v_50]; 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_631] = { let __args: [G; IN_631] = [__v_38, __v_39, __v_49, __v_50]; 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_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_35, __v_36, __v_51, __v_52]; 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_631] = { let __args: [G; IN_631] = [__v_35, __v_36, __v_51, __v_52]; 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_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_32, __v_33, __v_53, __v_54]; 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_631] = { let __args: [G; IN_631] = [__v_32, __v_33, __v_53, __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 = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_29, __v_30, __v_55, __v_56]; 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_631] = { let __args: [G; IN_631] = [__v_29, __v_30, __v_55, __v_56]; 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_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_26, __v_27, __v_57, __v_58]; 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_631] = { let __args: [G; IN_631] = [__v_26, __v_27, __v_57, __v_58]; 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_59: G = __r_arr[0];
             let __v_60: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_59, __v_60];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_653] = [__v_59, __v_60];
+            record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56995,15 +55071,15 @@ fn aiur_fn_678(
   })
 }
 
-const INPUT_SIZE_679: usize = 5;
-const IN_679: usize = 5;
-const OUT_679: usize = 2;
-fn aiur_fn_679(
-  inp: [G; IN_679],
+const INPUT_SIZE_654: usize = 5;
+const IN_654: usize = 5;
+const OUT_654: usize = 2;
+fn aiur_fn_654(
+  inp: [G; IN_654],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_679], ExecError> {
+) -> Result<[G; OUT_654], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57016,11 +55092,11 @@ fn aiur_fn_679(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_679] = [__v_8, __v_9];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_654] = [__v_8, __v_9];
+        record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57030,15 +55106,15 @@ fn aiur_fn_679(
         let __v_10: G = __loaded[2];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = []; 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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = []; 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_679] = [__v_11, __v_12];
-            record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_11, __v_12];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_6]; 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 __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];
@@ -57052,7 +55128,7 @@ fn aiur_fn_679(
             let __v_20: G = __loaded[8];
             let __v_21: G = __loaded[9];
             let __v_22: G = __loaded[10];
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_9]; 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 __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];
@@ -57066,17 +55142,17 @@ fn aiur_fn_679(
             let __v_32: G = __loaded[8];
             let __v_33: G = __loaded[9];
             let __v_34: G = __loaded[10];
-            let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[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 __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__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[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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_7, __v_10, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_7, __v_10, __v_2, __v_3, __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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_35, __v_36, __v_37, __v_38]; 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_631] = { let __args: [G; IN_631] = [__v_35, __v_36, __v_37, __v_38]; 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_679] = [__v_39, __v_40];
-            record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_39, __v_40];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57091,15 +55167,15 @@ fn aiur_fn_679(
   })
 }
 
-const INPUT_SIZE_680: usize = 24;
-const IN_680: usize = 24;
-const OUT_680: usize = 2;
-fn aiur_fn_680(
-  inp: [G; IN_680],
+const INPUT_SIZE_655: usize = 24;
+const IN_655: usize = 24;
+const OUT_655: usize = 2;
+fn aiur_fn_655(
+  inp: [G; IN_655],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_680], 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];
@@ -57129,161 +55205,88 @@ fn aiur_fn_680(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_1, __v_12]; 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_626] = { let __args: [G; IN_626] = [__v_1, __v_12]; 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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_24]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_24]; 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_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_15]; 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_626] = { let __args: [G; IN_626] = [__v_4, __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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_27]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_27]; 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_16]; 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_626] = { let __args: [G; IN_626] = [__v_5, __v_16]; 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 __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_30]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_30]; 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_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6, __v_17]; 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_626] = { let __args: [G; IN_626] = [__v_6, __v_17]; 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_33]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_33]; 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_13, __v_22, __v_23]; 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_642] = { let __args: [G; IN_642] = [__v_2, __v_13, __v_22, __v_23]; 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_36: G = __r_arr[0];
             let __v_37: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_34, __v_35, __v_36, __v_37]; 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_631] = { let __args: [G; IN_631] = [__v_34, __v_35, __v_36, __v_37]; 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_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_31, __v_32, __v_38, __v_39]; 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_631] = { let __args: [G; IN_631] = [__v_31, __v_32, __v_38, __v_39]; 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_40: G = __r_arr[0];
             let __v_41: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_28, __v_29, __v_40, __v_41]; 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_631] = { let __args: [G; IN_631] = [__v_28, __v_29, __v_40, __v_41]; 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_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_25, __v_26, __v_42, __v_43]; 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_631] = { let __args: [G; IN_631] = [__v_25, __v_26, __v_42, __v_43]; 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_44: G = __r_arr[0];
             let __v_45: G = __r_arr[1];
-            let __ret: [G; OUT_680] = [__v_44, __v_45];
-            record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_655] = [__v_44, __v_45];
+            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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 __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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 __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_24, __v_25]; 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_626] = { let __args: [G; IN_626] = [__v_24, __v_25]; 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_26]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_26]; 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_27: G = __r_arr[0];
             let __v_28: G = __r_arr[1];
-            let __ret: [G; OUT_680] = [__v_27, __v_28];
-            record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_655] = [__v_27, __v_28];
+            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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 __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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 __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_24, __v_25]; 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_626] = { let __args: [G; IN_626] = [__v_24, __v_25]; 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_26]; 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 __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_26]; 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
-        let __ret: [G; OUT_680] = [__v_27, __v_28];
-        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_655] = [__v_27, __v_28];
+        record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_681: usize = 4;
-const IN_681: usize = 4;
-const OUT_681: usize = 1;
-fn aiur_fn_681(
-  inp: [G; IN_681],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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 __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 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_681] = [__v_9];
-        record.function_queries[681].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_683] = { let __args: [G; IN_683] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; 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_18: G = __r_arr[0];
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = (__v_3 + __v_19);
-        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_6, __v_2, __v_20]; 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_18, __v_0]; 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_22: G = __r_arr[0];
-        match __v_22.as_canonical_u64() {
-          1u64 => {
-            let __v_23: G = G::from_u64(0);
-            let __v_24: G = { let __values: [G; 3] = [__v_23, __v_3, __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_681] = [__v_24];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __ret: [G; OUT_681] = [__v_21];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_682: usize = 2;
-const IN_682: usize = 2;
-const OUT_682: usize = 0;
-fn aiur_fn_682(
-  inp: [G; IN_682],
+const INPUT_SIZE_656: usize = 2;
+const IN_656: usize = 2;
+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_682], 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];
@@ -57324,22 +55327,22 @@ fn aiur_fn_682(
     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_684] = { let __args: [G; IN_684] = [__v_0, __v_34, __v_37, __v_38, __v_0, __v_1]; 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 __ret: [G; OUT_682] = [];
-    record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_34, __v_37, __v_38, __v_0, __v_1]; 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 __ret: [G; OUT_656] = [];
+    record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_683: usize = 12;
-const IN_683: usize = 12;
-const OUT_683: usize = 1;
-fn aiur_fn_683(
-  inp: [G; IN_683],
+const INPUT_SIZE_657: usize = 12;
+const IN_657: usize = 12;
+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_683], ExecError> {
+) -> Result<[G; OUT_657], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57355,12 +55358,12 @@ fn aiur_fn_683(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __ret: [G; OUT_683] = [__v_7];
-        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_657] = [__v_7];
+        record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_11, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_11, __v_3]; 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 __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];
@@ -57376,8 +55379,8 @@ fn aiur_fn_683(
         let __v_23: G = __loaded[10];
         match __v_13.as_canonical_u64() {
           5u64 => {
-            let __ret: [G; OUT_683] = [__v_20];
-            record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_657] = [__v_20];
+            record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57414,15 +55417,15 @@ fn aiur_fn_683(
             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_683] = [__v_56];
-            record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_657] = [__v_56];
+            record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       7u64 => {
-        let __ret: [G; OUT_683] = [__v_10];
-        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_657] = [__v_10];
+        record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57459,23 +55462,23 @@ fn aiur_fn_683(
         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_683] = [__v_44];
-        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_657] = [__v_44];
+        record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_684: usize = 6;
-const IN_684: usize = 6;
-const OUT_684: usize = 0;
-fn aiur_fn_684(
-  inp: [G; IN_684],
+const INPUT_SIZE_658: usize = 6;
+const IN_658: usize = 6;
+const OUT_658: usize = 0;
+fn aiur_fn_658(
+  inp: [G; IN_658],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_684], ExecError> {
+) -> 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];
@@ -57489,9 +55492,9 @@ fn aiur_fn_684(
     let __v_8: G = __loaded[2];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_1, __v_2, __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_684] = [];
-        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_1, __v_2, __v_4, __v_5]; 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 __ret: [G; OUT_658] = [];
+        record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57507,30 +55510,30 @@ fn aiur_fn_684(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__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[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 __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__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[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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_20, __v_1]; 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 __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_773] = { let __args: [G; IN_773] = [__v_2, __v_3]; 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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__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 __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_684] = { let __args: [G; IN_684] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_684] = [];
-            record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_658] = [];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_1, __v_2, __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_685] = { let __args: [G; IN_685] = [__v_20, __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_660] = { let __args: [G; IN_660] = [__v_1, __v_2, __v_4, __v_5]; 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 __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_20, __v_3]; 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_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_684] = { let __args: [G; IN_684] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_684] = [];
-            record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_658] = [];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57545,15 +55548,15 @@ fn aiur_fn_684(
   })
 }
 
-const INPUT_SIZE_685: usize = 2;
-const IN_685: usize = 2;
-const OUT_685: usize = 1;
-fn aiur_fn_685(
-  inp: [G; IN_685],
+const INPUT_SIZE_659: usize = 2;
+const IN_659: usize = 2;
+const OUT_659: usize = 1;
+fn aiur_fn_659(
+  inp: [G; IN_659],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_685], ExecError> {
+) -> Result<[G; OUT_659], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57590,15 +55593,15 @@ fn aiur_fn_685(
     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_130] = { let __args: [G; IN_130] = [__v_0, __v_34]; 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 __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_685] = [__v_38];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_659] = [__v_38];
+        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57607,8 +55610,8 @@ fn aiur_fn_685(
         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_685] = [__v_40];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_659] = [__v_40];
+        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57618,15 +55621,15 @@ fn aiur_fn_685(
   })
 }
 
-const INPUT_SIZE_686: usize = 4;
-const IN_686: usize = 4;
-const OUT_686: usize = 0;
-fn aiur_fn_686(
-  inp: [G; IN_686],
+const INPUT_SIZE_660: usize = 4;
+const IN_660: usize = 4;
+const OUT_660: usize = 0;
+fn aiur_fn_660(
+  inp: [G; IN_660],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_686], ExecError> {
+) -> Result<[G; OUT_660], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57665,32 +55668,32 @@ fn aiur_fn_686(
     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_130] = { let __args: [G; IN_130] = [__v_0, __v_36]; 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 __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() {
       1u64 => {
-        let __ret: [G; OUT_686] = [];
-        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_660] = [];
+        record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; 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 __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_686] = [];
-            record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_660] = [];
+            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __ret: [G; OUT_686] = [];
-            record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_660] = [];
+            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_1, __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 __ret: [G; OUT_686] = [];
-            record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __v_2, __v_3]; 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 __ret: [G; OUT_660] = [];
+            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57702,42 +55705,42 @@ fn aiur_fn_686(
   })
 }
 
-const INPUT_SIZE_687: usize = 3;
-const IN_687: usize = 3;
-const OUT_687: usize = 0;
-fn aiur_fn_687(
-  inp: [G; IN_687],
+const INPUT_SIZE_661: usize = 3;
+const IN_661: usize = 3;
+const OUT_661: usize = 0;
+fn aiur_fn_661(
+  inp: [G; IN_661],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_687], ExecError> {
+) -> 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 __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_0, __v_1]; 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_662] = { let __args: [G; IN_662] = [__v_0, __v_1]; 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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_687] = [];
-        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_661] = [];
+        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_687] = [];
-        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_661] = [];
+        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_3, __v_1, __v_2]; 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_665] = { let __args: [G; IN_665] = [__v_3, __v_1, __v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_5]; 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_663] = { let __args: [G; IN_663] = [__v_5]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_5]; 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 __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_5]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_7, __v_3]; 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 __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_7, __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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         if (__v_6 != __v_9) {
@@ -57747,23 +55750,23 @@ fn aiur_fn_687(
         if (__v_8 != __v_10) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
         }
-        let __ret: [G; OUT_687] = [];
-        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_661] = [];
+        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_688: usize = 2;
-const IN_688: usize = 2;
-const OUT_688: usize = 1;
-fn aiur_fn_688(
-  inp: [G; IN_688],
+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_688], 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];
@@ -57776,12 +55779,12 @@ fn aiur_fn_688(
         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_688] = [__v_7];
-        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_662] = [__v_7];
+        record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_3]; 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 __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];
@@ -57795,21 +55798,21 @@ fn aiur_fn_688(
         let __v_14: G = __loaded[8];
         let __v_15: G = __loaded[9];
         let __v_16: G = __loaded[10];
-        let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_4, __v_1]; 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_662] = { let __args: [G; IN_662] = [__v_4, __v_1]; 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_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__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[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 __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[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_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_688] = [__v_20];
-            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_20];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_688] = [__v_17];
-            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_17];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57821,15 +55824,15 @@ fn aiur_fn_688(
   })
 }
 
-const INPUT_SIZE_689: usize = 1;
-const IN_689: usize = 1;
-const OUT_689: usize = 1;
-fn aiur_fn_689(
-  inp: [G; IN_689],
+const INPUT_SIZE_663: usize = 1;
+const IN_663: usize = 1;
+const OUT_663: usize = 1;
+fn aiur_fn_663(
+  inp: [G; IN_663],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_689], ExecError> {
+) -> Result<[G; OUT_663], 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 };
@@ -57839,25 +55842,25 @@ fn aiur_fn_689(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_689] = [__v_4];
-        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_4];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__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 __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_689] = { let __args: [G; IN_689] = [__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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_3]; 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_5: G = __r_arr[0];
-            let __ret: [G; OUT_689] = [__v_5];
-            record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_663] = [__v_5];
+            record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_689] = [__v_5];
-            record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_663] = [__v_5];
+            record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57869,15 +55872,15 @@ fn aiur_fn_689(
   })
 }
 
-const INPUT_SIZE_690: usize = 1;
-const IN_690: usize = 1;
-const OUT_690: usize = 1;
-fn aiur_fn_690(
-  inp: [G; IN_690],
+const INPUT_SIZE_664: usize = 1;
+const IN_664: usize = 1;
+const OUT_664: usize = 1;
+fn aiur_fn_664(
+  inp: [G; IN_664],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_690], ExecError> {
+) -> Result<[G; OUT_664], 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 };
@@ -57889,17 +55892,17 @@ fn aiur_fn_690(
         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_690] = [__v_6];
-        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_664] = [__v_6];
+        record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_3]; 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 __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_3]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_2, __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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_2, __v_4]; 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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_690] = [__v_5];
-        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_664] = [__v_5];
+        record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57909,15 +55912,15 @@ fn aiur_fn_690(
   })
 }
 
-const INPUT_SIZE_691: usize = 3;
-const IN_691: usize = 3;
-const OUT_691: usize = 1;
-fn aiur_fn_691(
-  inp: [G; IN_691],
+const INPUT_SIZE_665: usize = 3;
+const IN_665: usize = 3;
+const OUT_665: usize = 1;
+fn aiur_fn_665(
+  inp: [G; IN_665],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_691], 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];
@@ -57928,26 +55931,26 @@ fn aiur_fn_691(
     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_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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_692] = { let __args: [G; IN_692] = [__v_7, __v_1, __v_2, __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 __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_7, __v_1, __v_2, __v_10]; 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_11: G = __r_arr[0];
-    let __ret: [G; OUT_691] = [__v_11];
-    record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_665] = [__v_11];
+    record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_692: usize = 4;
-const IN_692: usize = 4;
-const OUT_692: usize = 1;
-fn aiur_fn_692(
-  inp: [G; IN_692],
+const INPUT_SIZE_666: usize = 4;
+const IN_666: usize = 4;
+const OUT_666: usize = 1;
+fn aiur_fn_666(
+  inp: [G; IN_666],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_692], ExecError> {
+) -> Result<[G; OUT_666], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57955,30 +55958,30 @@ fn aiur_fn_692(
     let __v_3: G = inp[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_692] = [__v_0];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_666] = [__v_0];
+        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_1]; 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 __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_0, __v_1]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_4, __v_1, __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 __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0, __v_4, __v_1, __v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_692] = [__v_0];
-            record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_666] = [__v_0];
+            record.function_queries[666].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_692] = { let __args: [G; IN_692] = [__v_5, __v_1, __v_2, __v_8]; 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 __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_5, __v_1, __v_2, __v_8]; 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 __ret: [G; OUT_692] = [__v_9];
-            record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_666] = [__v_9];
+            record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57987,38 +55990,38 @@ fn aiur_fn_692(
   })
 }
 
-const INPUT_SIZE_693: usize = 2;
-const IN_693: usize = 2;
-const OUT_693: usize = 1;
-fn aiur_fn_693(
-  inp: [G; IN_693],
+const INPUT_SIZE_667: usize = 2;
+const IN_667: usize = 2;
+const OUT_667: usize = 1;
+fn aiur_fn_667(
+  inp: [G; IN_667],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_693], ExecError> {
+) -> Result<[G; OUT_667], ExecError> {
   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_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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_694] = { let __args: [G; IN_694] = [__v_0, __v_1, __v_2, __v_3]; 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_668] = { let __args: [G; IN_668] = [__v_0, __v_1, __v_2, __v_3]; 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_4: G = __r_arr[0];
-    let __ret: [G; OUT_693] = [__v_4];
-    record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_667] = [__v_4];
+    record.function_queries[667].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_668: usize = 4;
+const IN_668: usize = 4;
+const OUT_668: usize = 1;
+fn aiur_fn_668(
+  inp: [G; IN_668],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_694], ExecError> {
+) -> 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];
@@ -58033,23 +56036,23 @@ fn aiur_fn_694(
         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_694] = [__v_9];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_668] = [__v_9];
+        record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_5, __v_1, __v_2, __v_3]; 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_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_694] = { let __args: [G; IN_694] = [__v_6, __v_1, __v_10, __v_11]; 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_668] = { let __args: [G; IN_668] = [__v_6, __v_1, __v_10, __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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_7, __v_12]; 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 __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7, __v_12]; 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_13: G = __r_arr[0];
-        let __ret: [G; OUT_694] = [__v_13];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_668] = [__v_13];
+        record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58059,15 +56062,15 @@ fn aiur_fn_694(
   })
 }
 
-const INPUT_SIZE_695: usize = 4;
-const IN_695: usize = 4;
-const OUT_695: usize = 2;
-fn aiur_fn_695(
-  inp: [G; IN_695],
+const INPUT_SIZE_669: usize = 4;
+const IN_669: usize = 4;
+const OUT_669: usize = 2;
+fn aiur_fn_669(
+  inp: [G; IN_669],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_695], 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];
@@ -58083,15 +56086,15 @@ fn aiur_fn_695(
         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_695] = [__v_9, __v_10];
-        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_669] = [__v_9, __v_10];
+        record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_6, __v_1, __v_2, __v_3]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_5]; 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 __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];
@@ -58105,27 +56108,27 @@ fn aiur_fn_695(
         let __v_18: G = __loaded[8];
         let __v_19: G = __loaded[9];
         let __v_20: G = __loaded[10];
-        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__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[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_671] = { let __args: [G; IN_671] = [__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[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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_21]; 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 __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_696] = { let __args: [G; IN_696] = [__v_21, __v_3, __v_23]; 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 __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_21, __v_3, __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_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(0);
-        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_24, __v_7]; 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 __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24, __v_7]; 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_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_695] = [__v_27, __v_22];
-            record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_27, __v_22];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_695] = [__v_27, __v_8];
-            record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_27, __v_8];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58137,15 +56140,15 @@ fn aiur_fn_695(
   })
 }
 
-const INPUT_SIZE_696: usize = 3;
-const IN_696: usize = 3;
-const OUT_696: usize = 1;
-fn aiur_fn_696(
-  inp: [G; IN_696],
+const INPUT_SIZE_670: usize = 3;
+const IN_670: usize = 3;
+const OUT_670: usize = 1;
+fn aiur_fn_670(
+  inp: [G; IN_670],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_696], ExecError> {
+) -> 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];
@@ -58159,8 +56162,8 @@ fn aiur_fn_696(
         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_696] = [__v_8];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_670] = [__v_8];
+        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -58168,11 +56171,11 @@ fn aiur_fn_696(
         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_696] = { let __args: [G; IN_696] = [__v_5, __v_1, __v_9]; 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 __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_5, __v_1, __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 = { 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_696] = [__v_11];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_670] = [__v_11];
+        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58182,15 +56185,15 @@ fn aiur_fn_696(
   })
 }
 
-const INPUT_SIZE_697: usize = 11;
-const IN_697: usize = 11;
-const OUT_697: usize = 1;
-fn aiur_fn_697(
-  inp: [G; IN_697],
+const INPUT_SIZE_671: usize = 11;
+const IN_671: usize = 11;
+const OUT_671: usize = 1;
+fn aiur_fn_671(
+  inp: [G; IN_671],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_697], 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];
@@ -58205,31 +56208,31 @@ fn aiur_fn_697(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __ret: [G; OUT_697] = [__v_5];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_671] = [__v_5];
+        record.function_queries[671].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 __ret: [G; OUT_697] = [__v_13];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_671] = [__v_13];
+        record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_698: usize = 4;
-const IN_698: usize = 4;
-const OUT_698: usize = 1;
-fn aiur_fn_698(
-  inp: [G; IN_698],
+const INPUT_SIZE_672: usize = 4;
+const IN_672: usize = 4;
+const OUT_672: usize = 1;
+fn aiur_fn_672(
+  inp: [G; IN_672],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_698], ExecError> {
+) -> 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];
@@ -58244,19 +56247,19 @@ fn aiur_fn_698(
         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_698] = [__v_9];
-        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_672] = [__v_9];
+        record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_5, __v_1, __v_2, __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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_1, __v_2, __v_3]; 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 __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_7, __v_8]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_7, __v_8]; 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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_698] = [__v_9];
-        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_672] = [__v_9];
+        record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58266,29 +56269,29 @@ fn aiur_fn_698(
   })
 }
 
-const INPUT_SIZE_699: usize = 4;
-const IN_699: usize = 4;
-const OUT_699: usize = 1;
-fn aiur_fn_699(
-  inp: [G; IN_699],
+const INPUT_SIZE_673: usize = 4;
+const IN_673: usize = 4;
+const OUT_673: usize = 1;
+fn aiur_fn_673(
+  inp: [G; IN_673],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_699], 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];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; 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 __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() {
       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_699] = [__v_7];
-        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_673] = [__v_7];
+        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -58297,32 +56300,32 @@ fn aiur_fn_699(
         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_699] = [__v_9];
-        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_673] = [__v_9];
+        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __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_674] = { let __args: [G; IN_674] = [__v_0, __v_1, __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_5, __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 __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_5, __v_1, __v_2, __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_6: G = __r_arr[0];
-        let __ret: [G; OUT_699] = [__v_6];
-        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_673] = [__v_6];
+        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_674: usize = 4;
+const IN_674: usize = 4;
+const OUT_674: usize = 1;
+fn aiur_fn_674(
+  inp: [G; IN_674],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_700], ExecError> {
+) -> 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];
@@ -58337,17 +56340,17 @@ fn aiur_fn_700(
         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 __ret: [G; OUT_674] = [__v_9];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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_674] = { let __args: [G; IN_674] = [__v_6, __v_1, __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_5, __v_7, __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 __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_5, __v_7, __v_1, __v_2, __v_3]; 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_700] = [__v_8];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_8];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58357,15 +56360,15 @@ fn aiur_fn_700(
   })
 }
 
-const INPUT_SIZE_701: usize = 5;
-const IN_701: usize = 5;
-const OUT_701: usize = 1;
-fn aiur_fn_701(
-  inp: [G; IN_701],
+const INPUT_SIZE_675: usize = 5;
+const IN_675: usize = 5;
+const OUT_675: usize = 1;
+fn aiur_fn_675(
+  inp: [G; IN_675],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_701], ExecError> {
+) -> Result<[G; OUT_675], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58383,12 +56386,12 @@ fn aiur_fn_701(
         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_701] = [__v_12];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_675] = [__v_12];
+        record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_0]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_0]; 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 __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];
@@ -58402,7 +56405,7 @@ fn aiur_fn_701(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_6]; 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 __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];
@@ -58416,24 +56419,24 @@ fn aiur_fn_701(
         let __v_29: G = __loaded[8];
         let __v_30: G = __loaded[9];
         let __v_31: G = __loaded[10];
-        let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__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[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 __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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_701] = [__v_35];
-            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_675] = [__v_35];
+            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_34: G = G::from_u64(0);
-            let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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 __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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_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_701] = [__v_36];
-            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_675] = [__v_36];
+            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58445,15 +56448,15 @@ fn aiur_fn_701(
   })
 }
 
-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_676: usize = 4;
+const IN_676: usize = 4;
+const OUT_676: usize = 1;
+fn aiur_fn_676(
+  inp: [G; IN_676],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_702], ExecError> {
+) -> Result<[G; OUT_676], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58468,8 +56471,8 @@ fn aiur_fn_702(
         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));
+        let __ret: [G; OUT_676] = [__v_9];
+        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -58478,10 +56481,10 @@ fn aiur_fn_702(
         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_703] = { let __args: [G; IN_703] = [__v_6, __v_1, __v_2, __v_3, __v_5, __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 __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_6, __v_1, __v_2, __v_3, __v_5, __v_11]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_702] = [__v_12];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_676] = [__v_12];
+        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58491,15 +56494,15 @@ fn aiur_fn_702(
   })
 }
 
-const INPUT_SIZE_703: usize = 6;
-const IN_703: usize = 6;
-const OUT_703: usize = 1;
-fn aiur_fn_703(
-  inp: [G; IN_703],
+const INPUT_SIZE_677: usize = 6;
+const IN_677: usize = 6;
+const OUT_677: usize = 1;
+fn aiur_fn_677(
+  inp: [G; IN_677],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_703], 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];
@@ -58518,12 +56521,12 @@ fn aiur_fn_703(
         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_703] = [__v_13];
-        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_677] = [__v_13];
+        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_4]; 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 __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];
@@ -58537,7 +56540,7 @@ fn aiur_fn_703(
         let __v_18: G = __loaded[8];
         let __v_19: G = __loaded[9];
         let __v_20: G = __loaded[10];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_7]; 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 __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];
@@ -58551,17 +56554,17 @@ fn aiur_fn_703(
         let __v_30: G = __loaded[8];
         let __v_31: G = __loaded[9];
         let __v_32: G = __loaded[10];
-        let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__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[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 __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_33: G = __r_arr[0];
         let __v_34: G = __r_arr[1];
         match __v_33.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_5, __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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_5, __v_7]; 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 __v_35: G = __r_arr[0];
-            let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_35]; 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 __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_35]; 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_36: G = __r_arr[0];
-            let __ret: [G; OUT_703] = [__v_36];
-            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_677] = [__v_36];
+            record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -58571,11 +56574,11 @@ fn aiur_fn_703(
             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_703] = { let __args: [G; IN_703] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_40]; 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 __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_40]; 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_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_703] = [__v_42];
-            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_677] = [__v_42];
+            record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58587,15 +56590,15 @@ fn aiur_fn_703(
   })
 }
 
-const INPUT_SIZE_704: usize = 2;
-const IN_704: usize = 2;
-const OUT_704: usize = 1;
-fn aiur_fn_704(
-  inp: [G; IN_704],
+const INPUT_SIZE_678: usize = 2;
+const IN_678: usize = 2;
+const OUT_678: usize = 1;
+fn aiur_fn_678(
+  inp: [G; IN_678],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_704], 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];
@@ -58612,14 +56615,14 @@ fn aiur_fn_704(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_704] = [__v_8];
-            record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_8];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_704] = [__v_8];
-            record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_8];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58632,25 +56635,25 @@ fn aiur_fn_704(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_704] = [__v_8];
-            record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_8];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_704] = [__v_9];
-                record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_678] = [__v_9];
+                record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_704] = [__v_9];
-                record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_678] = [__v_9];
+                record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -58667,15 +56670,15 @@ fn aiur_fn_704(
   })
 }
 
-const INPUT_SIZE_705: usize = 11;
-const IN_705: usize = 11;
-const OUT_705: usize = 1;
-fn aiur_fn_705(
-  inp: [G; IN_705],
+const INPUT_SIZE_679: usize = 11;
+const IN_679: usize = 11;
+const OUT_679: usize = 1;
+fn aiur_fn_679(
+  inp: [G; IN_679],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_705], 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];
@@ -58690,56 +56693,56 @@ fn aiur_fn_705(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_705] = [__v_3];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_3];
+        record.function_queries[679].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_705] = [__v_11];
-            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_679] = [__v_11];
+            record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_705] = [__v_11];
-            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_705] = [__v_11];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_11];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_705] = [__v_4];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_4];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_705] = [__v_11];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_11];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_705] = [__v_6];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_6];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_705] = [__v_7];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_7];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_705] = [__v_9];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_9];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58749,15 +56752,15 @@ fn aiur_fn_705(
   })
 }
 
-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_680: usize = 2;
+const IN_680: usize = 2;
+const OUT_680: usize = 1;
+fn aiur_fn_680(
+  inp: [G; IN_680],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_706], ExecError> {
+) -> Result<[G; OUT_680], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58769,18 +56772,18 @@ fn aiur_fn_706(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_706] = [__v_6];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_6];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_706] = [__v_6];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_6];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_3]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_3]; 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 __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];
@@ -58795,67 +56798,67 @@ fn aiur_fn_706(
         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_705] = { let __args: [G; IN_705] = [__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[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 __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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[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_19: G = __r_arr[0];
         let __v_20: G = (__v_18 - __v_19);
-        let __ret: [G; OUT_706] = [__v_20];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_20];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
         let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_706] = [__v_8];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_8];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
         let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_706] = [__v_8];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_8];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
         let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_706] = [__v_8];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_8];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4, __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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_1]; 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_7: G = __r_arr[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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_5, __v_1]; 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_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_706] = [__v_10];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_10];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_706] = [__v_6];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_6];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_5, __v_1]; 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_706] = [__v_6];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_6];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58865,34 +56868,34 @@ fn aiur_fn_706(
   })
 }
 
-const INPUT_SIZE_707: usize = 3;
-const IN_707: usize = 3;
-const OUT_707: usize = 0;
-fn aiur_fn_707(
-  inp: [G; IN_707],
+const INPUT_SIZE_681: usize = 3;
+const IN_681: usize = 3;
+const OUT_681: usize = 0;
+fn aiur_fn_681(
+  inp: [G; IN_681],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_707], 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 __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_707] = [];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_681] = [];
+        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_1, __v_2]; 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_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 __ret: [G; OUT_707] = [];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_681] = [];
+        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58902,15 +56905,15 @@ fn aiur_fn_707(
   })
 }
 
-const INPUT_SIZE_708: usize = 2;
-const IN_708: usize = 2;
-const OUT_708: usize = 0;
-fn aiur_fn_708(
-  inp: [G; IN_708],
+const INPUT_SIZE_682: usize = 2;
+const IN_682: usize = 2;
+const OUT_682: usize = 0;
+fn aiur_fn_682(
+  inp: [G; IN_682],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_708], 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];
@@ -58920,28 +56923,28 @@ fn aiur_fn_708(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_682] = [];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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 __ret: [G; OUT_708] = [];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_3, __v_1]; 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 __ret: [G; OUT_682] = [];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        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 __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 __ret: [G; OUT_708] = [];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_4, __v_1]; 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 __ret: [G; OUT_682] = [];
+        record.function_queries[682].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 __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 __ret: [G; OUT_708] = [];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_4, __v_1]; 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 __ret: [G; OUT_682] = [];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
@@ -58950,8 +56953,8 @@ fn aiur_fn_708(
         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_708] = [];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_682] = [];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58961,15 +56964,15 @@ fn aiur_fn_708(
   })
 }
 
-const INPUT_SIZE_709: usize = 2;
-const IN_709: usize = 2;
-const OUT_709: usize = 0;
-fn aiur_fn_709(
-  inp: [G; IN_709],
+const INPUT_SIZE_683: usize = 2;
+const IN_683: usize = 2;
+const OUT_683: usize = 0;
+fn aiur_fn_683(
+  inp: [G; IN_683],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_709], 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];
@@ -58979,15 +56982,15 @@ fn aiur_fn_709(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_709] = [];
-        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_683] = [];
+        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_4, __v_1]; 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_709] = [];
-        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_3, __v_1]; 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 __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_4, __v_1]; 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 __ret: [G; OUT_683] = [];
+        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58997,15 +57000,15 @@ fn aiur_fn_709(
   })
 }
 
-const INPUT_SIZE_710: usize = 4;
-const IN_710: usize = 4;
-const OUT_710: usize = 0;
-fn aiur_fn_710(
-  inp: [G; IN_710],
+const INPUT_SIZE_684: usize = 4;
+const IN_684: usize = 4;
+const OUT_684: usize = 0;
+fn aiur_fn_684(
+  inp: [G; IN_684],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_710], 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];
@@ -59023,18 +57026,18 @@ fn aiur_fn_710(
         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_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5, __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 __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_5, __v_2]; 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 __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_5]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_3, __v_5]; 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 __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];
@@ -59048,62 +57051,62 @@ fn aiur_fn_710(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__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[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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__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[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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; 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 __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_709] = { let __args: [G; IN_709] = [__v_6, __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 __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_6, __v_2]; 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 __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5, __v_1, __v_2, __v_3]; 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_6, __v_1, __v_2, __v_3]; 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));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_5, __v_1, __v_2, __v_3]; 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_684] = { let __args: [G; IN_684] = [__v_6, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5, __v_1, __v_2, __v_3]; 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_684] = { let __args: [G; IN_684] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_6, __v_9, __v_2, __v_3]; 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));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5, __v_1, __v_2, __v_3]; 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_684] = { let __args: [G; IN_684] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_6, __v_9, __v_2, __v_3]; 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));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5, __v_1, __v_2, __v_3]; 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_6, __v_1, __v_2, __v_3]; 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_684] = { let __args: [G; IN_684] = [__v_5, __v_1, __v_2, __v_3]; 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_684] = { let __args: [G; IN_684] = [__v_6, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_7, __v_9, __v_2, __v_3]; 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));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_7, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_7, __v_1, __v_2, __v_3]; 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));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_7, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_684] = [];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59113,15 +57116,15 @@ fn aiur_fn_710(
   })
 }
 
-const INPUT_SIZE_711: usize = 12;
-const IN_711: usize = 12;
-const OUT_711: usize = 0;
-fn aiur_fn_711(
-  inp: [G; IN_711],
+const INPUT_SIZE_685: usize = 12;
+const IN_685: usize = 12;
+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_711], ExecError> {
+) -> 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];
@@ -59135,58 +57138,58 @@ fn aiur_fn_711(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__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[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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__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[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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__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[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 __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__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[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 = __r_arr[0];
     let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_13, __v_14, __v_12, __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 __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_14, __v_12, __v_11]; 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)? } };
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_711] = [];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_685] = [];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_711] = [];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_685] = [];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_711] = [];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_685] = [];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_7, __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_711] = [];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_7, __v_12, __v_11]; 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_685] = [];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_711] = [];
-        record.function_queries[711].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);
       },
     }
   })
 }
 
-const INPUT_SIZE_712: usize = 3;
-const IN_712: usize = 3;
-const OUT_712: usize = 0;
-fn aiur_fn_712(
-  inp: [G; IN_712],
+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_712], ExecError> {
+) -> 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];
@@ -59199,18 +57202,18 @@ fn aiur_fn_712(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_686] = [];
+        record.function_queries[686].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_710] = { let __args: [G; IN_710] = [__v_6, __v_8, __v_1, __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 __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_7, __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 __ret: [G; OUT_712] = [];
-            record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_6, __v_8, __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_686] = { let __args: [G; IN_686] = [__v_7, __v_1, __v_2]; 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);
           },
         }
@@ -59222,24 +57225,24 @@ fn aiur_fn_712(
   })
 }
 
-const INPUT_SIZE_713: usize = 2;
-const IN_713: usize = 2;
-const OUT_713: usize = 0;
-fn aiur_fn_713(
-  inp: [G; IN_713],
+const INPUT_SIZE_687: usize = 2;
+const IN_687: usize = 2;
+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_713], 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 __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 __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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_1, __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 __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_1, __v_3]; 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_4]; 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 __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];
@@ -59256,9 +57259,9 @@ fn aiur_fn_713(
     match __v_6.as_canonical_u64() {
       5u64 => {
         let __v_17: G = G::from_u64(0);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_11, __v_17]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_11, __v_17]; 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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_1, __v_18]; 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 __v_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(1);
         if (__v_7 != __v_20) {
@@ -59268,22 +57271,22 @@ fn aiur_fn_713(
         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_200] = { let __args: [G; IN_200] = [__v_11]; 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 __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_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 __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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_19, __v_24]; 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 __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_713] = [];
-        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_687] = [];
+        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59293,15 +57296,15 @@ fn aiur_fn_713(
   })
 }
 
-const INPUT_SIZE_714: usize = 14;
-const IN_714: usize = 14;
-const OUT_714: usize = 0;
-fn aiur_fn_714(
-  inp: [G; IN_714],
+const INPUT_SIZE_688: usize = 14;
+const IN_688: usize = 14;
+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_714], ExecError> {
+) -> Result<[G; OUT_688], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59317,83 +57320,83 @@ fn aiur_fn_714(
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
-    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__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[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 __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__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[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 __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__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[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_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_14: G = __r_arr[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         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_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __ret: [G; OUT_688] = [];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       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 __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_3, __v_12]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_3, __v_12]; 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_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_455] = { let __args: [G; IN_455] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_688] = [];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         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_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_3, __v_12]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_3, __v_12]; 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_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_455] = { let __args: [G; IN_455] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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_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_229] = { let __args: [G; IN_229] = [__v_18, __v_24]; 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 __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 __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_688] = [];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         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_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_3, __v_12]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_3, __v_12]; 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)? } };
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_714] = [];
-            record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_688] = [];
+            record.function_queries[688].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_455] = { let __args: [G; IN_455] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_714] = [];
-            record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_688] = [];
+            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59405,38 +57408,38 @@ fn aiur_fn_714(
         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_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_13, __v_11]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_13, __v_11]; 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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; 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 __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; 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);
       },
       5u64 => {
         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_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_2, __v_3, __v_4, __v_7, __v_12, __v_13]; 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 __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_11, __v_12, __v_13]; 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 __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_11, __v_2, __v_3, __v_4, __v_7, __v_12, __v_13]; 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 __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_11, __v_12, __v_13]; 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 __ret: [G; OUT_688] = [];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         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_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__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[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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_12, __v_3]; 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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__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[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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_12, __v_3]; 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 __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];
@@ -59452,27 +57455,27 @@ fn aiur_fn_714(
         let __v_30: G = __loaded[10];
         match __v_20.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_22, __v_2, __v_23, __v_12, __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 __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21, __v_12]; 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 __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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 __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21, __v_12]; 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_31: G = (__v_23 + __v_24);
             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 __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_22, __v_31, __v_34, __v_12, __v_13]; 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 __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_22, __v_31, __v_34, __v_12, __v_13]; 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_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_509] = { let __args: [G; IN_509] = [__v_2, __v_5, __v_35, __v_38, __v_12, __v_13]; 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 __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_5, __v_35, __v_38, __v_12, __v_13]; 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_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_512] = { let __args: [G; IN_512] = [__v_2, __v_5, __v_3, __v_41, __v_12, __v_13]; 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 __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_5, __v_3, __v_41, __v_12, __v_13]; 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)? } };
             if (__v_5 != __v_23) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
             }
-            let __ret: [G; OUT_714] = [];
-            record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_688] = [];
+            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59484,12 +57487,12 @@ fn aiur_fn_714(
         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_454] = { let __args: [G; IN_454] = [__v_2, __v_17, __v_12, __v_13]; 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 __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__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[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 __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_14, __v_2, __v_12]; 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 __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__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[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 __ret: [G; OUT_688] = [];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59499,15 +57502,15 @@ fn aiur_fn_714(
   })
 }
 
-const INPUT_SIZE_715: usize = 6;
-const IN_715: usize = 6;
-const OUT_715: usize = 0;
-fn aiur_fn_715(
-  inp: [G; IN_715],
+const INPUT_SIZE_689: usize = 6;
+const IN_689: usize = 6;
+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_715], ExecError> {
+) -> 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];
@@ -59517,9 +57520,9 @@ fn aiur_fn_715(
     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_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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = []; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_6]; 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 __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) {
@@ -59530,9 +57533,9 @@ fn aiur_fn_715(
     break '__mc_0 [__v_9, __v_10];
   },
   1u64 => {
-    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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = []; 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_130] = { let __args: [G; IN_130] = [__v_0, __v_6]; 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 __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) {
@@ -59543,10 +57546,10 @@ fn aiur_fn_715(
     break '__mc_0 [__v_9, __v_10];
   },
   2u64 => {
-    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __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 __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 __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_4, __v_5]; 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_229] = { let __args: [G; IN_229] = []; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_6]; 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 __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) {
@@ -59557,9 +57560,9 @@ fn aiur_fn_715(
     break '__mc_0 [__v_9, __v_10];
   },
   3u64 => {
-    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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = []; 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_6]; 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 __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) {
@@ -59580,27 +57583,27 @@ fn aiur_fn_715(
       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_716] = { let __args: [G; IN_716] = [__v_3, __v_7, __v_8]; 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 __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_3, __v_7, __v_8]; 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_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_715] = [];
-    record.function_queries[715].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);
   })
 }
 
-const INPUT_SIZE_716: usize = 3;
-const IN_716: usize = 3;
-const OUT_716: usize = 1;
-fn aiur_fn_716(
-  inp: [G; IN_716],
+const INPUT_SIZE_690: usize = 3;
+const IN_690: usize = 3;
+const OUT_690: usize = 1;
+fn aiur_fn_690(
+  inp: [G; IN_690],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_716], ExecError> {
+) -> Result<[G; OUT_690], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59609,8 +57612,8 @@ fn aiur_fn_716(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_716] = [__v_4];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_690] = [__v_4];
+        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59623,16 +57626,16 @@ fn aiur_fn_716(
           5u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 + __v_8);
-            let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_6, __v_1, __v_9]; 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 __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_6, __v_1, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_716] = [__v_10];
-            record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_690] = [__v_10];
+            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_716] = [__v_8];
-            record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_690] = [__v_8];
+            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -59641,37 +57644,37 @@ fn aiur_fn_716(
   })
 }
 
-const INPUT_SIZE_717: usize = 3;
-const IN_717: usize = 3;
-const OUT_717: usize = 0;
-fn aiur_fn_717(
-  inp: [G; IN_717],
+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_717], 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 __v_2: G = inp[2];
-    let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_1, __v_2]; 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_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_717] = [];
-    record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_1, __v_2, __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 __ret: [G; OUT_691] = [];
+    record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_718: usize = 4;
-const IN_718: usize = 4;
-const OUT_718: usize = 0;
-fn aiur_fn_718(
-  inp: [G; IN_718],
+const INPUT_SIZE_692: usize = 4;
+const IN_692: usize = 4;
+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_718], ExecError> {
+) -> Result<[G; OUT_692], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59683,8 +57686,8 @@ fn aiur_fn_718(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_718] = [];
-        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_692] = [];
+        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -59700,12 +57703,12 @@ fn aiur_fn_718(
         let __v_15: G = __loaded[8];
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
-        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__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[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 __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__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[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 __v_18: G = G::from_u64(1);
         let __v_19: G = (__v_3 + __v_18);
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_1, __v_2, __v_19]; 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 __ret: [G; OUT_718] = [];
-        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_1, __v_2, __v_19]; 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);
       },
       _ => {
@@ -59715,35 +57718,35 @@ fn aiur_fn_718(
   })
 }
 
-const INPUT_SIZE_719: usize = 1;
-const IN_719: usize = 1;
-const OUT_719: usize = 3;
-fn aiur_fn_719(
-  inp: [G; IN_719],
+const INPUT_SIZE_693: usize = 1;
+const IN_693: usize = 1;
+const OUT_693: usize = 3;
+fn aiur_fn_693(
+  inp: [G; IN_693],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_719], ExecError> {
+) -> Result<[G; OUT_693], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !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_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];
     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_719] = [__v_3, __v_4, __v_2];
-        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_693] = [__v_3, __v_4, __v_2];
+        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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_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_719] = [__v_5, __v_3, __v_4];
-        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_693] = [__v_5, __v_3, __v_4];
+        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59753,15 +57756,15 @@ fn aiur_fn_719(
   })
 }
 
-const INPUT_SIZE_720: usize = 2;
-const IN_720: usize = 2;
-const OUT_720: usize = 10;
-fn aiur_fn_720(
-  inp: [G; IN_720],
+const INPUT_SIZE_694: usize = 2;
+const IN_694: usize = 2;
+const OUT_694: usize = 10;
+fn aiur_fn_694(
+  inp: [G; IN_694],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_720], 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];
@@ -59769,12 +57772,12 @@ fn aiur_fn_720(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_720] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
-        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -59785,23 +57788,23 @@ fn aiur_fn_720(
         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_720] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_721: usize = 2;
-const IN_721: usize = 2;
-const OUT_721: usize = 3;
-fn aiur_fn_721(
-  inp: [G; IN_721],
+const INPUT_SIZE_695: usize = 2;
+const IN_695: usize = 2;
+const OUT_695: usize = 3;
+fn aiur_fn_695(
+  inp: [G; IN_695],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_721], 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];
@@ -59809,32 +57812,32 @@ fn aiur_fn_721(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_721] = [__v_2, __v_3, __v_1];
-        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_2, __v_3, __v_1];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_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_721] = [__v_4, __v_2, __v_3];
-        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_4, __v_2, __v_3];
+        record.function_queries[695].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 = 3;
-fn aiur_fn_722(
-  inp: [G; IN_722],
+const INPUT_SIZE_696: usize = 2;
+const IN_696: usize = 2;
+const OUT_696: usize = 3;
+fn aiur_fn_696(
+  inp: [G; IN_696],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_722], 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];
@@ -59842,32 +57845,32 @@ fn aiur_fn_722(
       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_1];
-        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_696] = [__v_2, __v_3, __v_1];
+        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; 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_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_722] = [__v_4, __v_2, __v_3];
-        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_696] = [__v_4, __v_2, __v_3];
+        record.function_queries[696].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_697: usize = 2;
+const IN_697: usize = 2;
+const OUT_697: usize = 3;
+fn aiur_fn_697(
+  inp: [G; IN_697],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_723], 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];
@@ -59875,34 +57878,34 @@ fn aiur_fn_723(
       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 __ret: [G; OUT_697] = [__v_2, __v_3, __v_1];
+        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; 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_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];
         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_723] = [__v_4, __v_5, __v_3];
-            record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_697] = [__v_4, __v_5, __v_3];
+            record.function_queries[697].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_723] = [__v_4, __v_5, __v_3];
-            record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_697] = [__v_4, __v_5, __v_3];
+            record.function_queries[697].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_723] = [__v_4, __v_5, __v_3];
-            record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_697] = [__v_4, __v_5, __v_3];
+            record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59914,15 +57917,15 @@ fn aiur_fn_723(
   })
 }
 
-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_698: usize = 2;
+const IN_698: usize = 2;
+const OUT_698: usize = 3;
+fn aiur_fn_698(
+  inp: [G; IN_698],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_724], 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];
@@ -59930,41 +57933,41 @@ fn aiur_fn_724(
       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 __ret: [G; OUT_698] = [__v_2, __v_3, __v_1];
+        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; 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_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];
         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_724] = [__v_4, __v_5, __v_3];
-            record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_698] = [__v_4, __v_5, __v_3];
+            record.function_queries[698].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_724] = [__v_4, __v_5, __v_3];
-            record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_698] = [__v_4, __v_5, __v_3];
+            record.function_queries[698].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_724] = [__v_4, __v_5, __v_3];
-            record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_698] = [__v_4, __v_5, __v_3];
+            record.function_queries[698].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_724] = [__v_4, __v_5, __v_3];
-            record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_698] = [__v_4, __v_5, __v_3];
+            record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59976,15 +57979,15 @@ fn aiur_fn_724(
   })
 }
 
-const INPUT_SIZE_725: usize = 9;
-const IN_725: usize = 9;
-const OUT_725: usize = 2;
-fn aiur_fn_725(
-  inp: [G; IN_725],
+const INPUT_SIZE_699: usize = 9;
+const IN_699: usize = 9;
+const OUT_699: usize = 2;
+fn aiur_fn_699(
+  inp: [G; IN_699],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_725], 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];
@@ -60002,12 +58005,12 @@ fn aiur_fn_725(
         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_725] = [__v_12, __v_0];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_699] = [__v_12, __v_0];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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 __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];
@@ -60026,7 +58029,7 @@ fn aiur_fn_725(
         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_17] = { let __args: [G; IN_17] = [__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[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_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];
@@ -60035,28 +58038,28 @@ fn aiur_fn_725(
         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_725] = { let __args: [G; IN_725] = [__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[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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__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[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_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_725] = [__v_39, __v_37];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_699] = [__v_39, __v_37];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_700: usize = 2;
+const IN_700: usize = 2;
+const OUT_700: usize = 3;
+fn aiur_fn_700(
+  inp: [G; IN_700],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_726], 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];
@@ -60064,12 +58067,12 @@ fn aiur_fn_726(
       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 __ret: [G; OUT_700] = [__v_2, __v_3, __v_1];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -60079,30 +58082,30 @@ fn aiur_fn_726(
         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_725] = { let __args: [G; IN_725] = [__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[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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__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[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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_726] = [__v_13, __v_11, __v_12];
-        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_700] = [__v_13, __v_11, __v_12];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_727: usize = 1;
-const IN_727: usize = 1;
-const OUT_727: usize = 41;
-fn aiur_fn_727(
-  inp: [G; IN_727],
+const INPUT_SIZE_701: usize = 1;
+const IN_701: usize = 1;
+const OUT_701: usize = 41;
+fn aiur_fn_701(
+  inp: [G; IN_701],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_727], ExecError> {
+) -> Result<[G; OUT_701], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -60121,11 +58124,11 @@ fn aiur_fn_727(
     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_722] = { let __args: [G; IN_722] = [__v_10, __v_9]; 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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_10, __v_9]; 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_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
-    let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_11, __v_20]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_11, __v_20]; 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -60136,7 +58139,7 @@ fn aiur_fn_727(
     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_720] = { let __args: [G; IN_720] = [__v_12, __v_30]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_12, __v_30]; 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_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -60147,7 +58150,7 @@ fn aiur_fn_727(
     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_720] = { let __args: [G; IN_720] = [__v_13, __v_40]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_40]; 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_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -60158,7 +58161,7 @@ fn aiur_fn_727(
     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_720] = { let __args: [G; IN_720] = [__v_14, __v_50]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_14, __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 __v_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -60169,28 +58172,28 @@ fn aiur_fn_727(
     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_721] = { let __args: [G; IN_721] = [__v_15, __v_60]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_15, __v_60]; 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_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
-    let __ret: [G; OUT_727] = [__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[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_701] = [__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[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_728: usize = 1;
-const IN_728: usize = 1;
-const OUT_728: usize = 49;
-fn aiur_fn_728(
-  inp: [G; IN_728],
+const INPUT_SIZE_702: usize = 1;
+const IN_702: usize = 1;
+const OUT_702: usize = 49;
+fn aiur_fn_702(
+  inp: [G; IN_702],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_728], ExecError> {
+) -> Result<[G; OUT_702], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -60200,7 +58203,7 @@ fn aiur_fn_728(
     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_727] = { let __args: [G; IN_727] = [__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 __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_9]; 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -60242,21 +58245,21 @@ fn aiur_fn_728(
     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_728] = [__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[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_702] = [__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[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_729: usize = 9;
-const IN_729: usize = 9;
-const OUT_729: usize = 2;
-fn aiur_fn_729(
-  inp: [G; IN_729],
+const INPUT_SIZE_703: usize = 9;
+const IN_703: usize = 9;
+const OUT_703: usize = 2;
+fn aiur_fn_703(
+  inp: [G; IN_703],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_729], ExecError> {
+) -> 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];
@@ -60274,12 +58277,12 @@ fn aiur_fn_729(
         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_729] = [__v_12, __v_0];
-        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_703] = [__v_12, __v_0];
+        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0]; 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 __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0]; 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60329,7 +58332,7 @@ fn aiur_fn_729(
         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_17] = { let __args: [G; IN_17] = [__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[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_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];
@@ -60338,28 +58341,28 @@ fn aiur_fn_729(
         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_729] = { let __args: [G; IN_729] = [__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[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 __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__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[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_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_729] = [__v_70, __v_68];
-        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_703] = [__v_70, __v_68];
+        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_730: usize = 2;
-const IN_730: usize = 2;
-const OUT_730: usize = 3;
-fn aiur_fn_730(
-  inp: [G; IN_730],
+const INPUT_SIZE_704: usize = 2;
+const IN_704: usize = 2;
+const OUT_704: usize = 3;
+fn aiur_fn_704(
+  inp: [G; IN_704],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_730], 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];
@@ -60367,12 +58370,12 @@ fn aiur_fn_730(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_730] = [__v_2, __v_3, __v_1];
-        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_704] = [__v_2, __v_3, __v_1];
+        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -60382,33 +58385,33 @@ fn aiur_fn_730(
         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_729] = { let __args: [G; IN_729] = [__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[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 __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__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[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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_730] = [__v_13, __v_11, __v_12];
-        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_704] = [__v_13, __v_11, __v_12];
+        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_731: usize = 1;
-const IN_731: usize = 1;
-const OUT_731: usize = 55;
-fn aiur_fn_731(
-  inp: [G; IN_731],
+const INPUT_SIZE_705: usize = 1;
+const IN_705: usize = 1;
+const OUT_705: usize = 55;
+fn aiur_fn_705(
+  inp: [G; IN_705],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_731], ExecError> {
+) -> Result<[G; OUT_705], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !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_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_76] = { let __args: [G; IN_76] = [__v_2]; 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_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];
@@ -60438,15 +58441,15 @@ fn aiur_fn_731(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; 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 __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_14, __v_33]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_14, __v_33]; 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60457,26 +58460,26 @@ fn aiur_fn_731(
         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_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_15, __v_43]; 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_46]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_16, __v_46]; 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_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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__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[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60487,7 +58490,7 @@ fn aiur_fn_731(
         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_720] = { let __args: [G; IN_720] = [__v_14, __v_40]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_14, __v_40]; 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_41: G = __r_arr[0];
         let __v_42: G = __r_arr[1];
         let __v_43: G = __r_arr[2];
@@ -60498,7 +58501,7 @@ fn aiur_fn_731(
         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_720] = { let __args: [G; IN_720] = [__v_15, __v_50]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_15, __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 __v_51: G = __r_arr[0];
         let __v_52: G = __r_arr[1];
         let __v_53: G = __r_arr[2];
@@ -60509,30 +58512,30 @@ fn aiur_fn_731(
         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_721] = { let __args: [G; IN_721] = [__v_16, __v_60]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_16, __v_60]; 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_61: G = __r_arr[0];
         let __v_62: G = __r_arr[1];
         let __v_63: G = __r_arr[2];
-        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_17, __v_63]; 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 __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_17, __v_63]; 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_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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__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[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __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_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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_14, __v_33]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_14, __v_33]; 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60543,7 +58546,7 @@ fn aiur_fn_731(
         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_720] = { let __args: [G; IN_720] = [__v_15, __v_43]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_15, __v_43]; 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -60554,7 +58557,7 @@ fn aiur_fn_731(
         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_720] = { let __args: [G; IN_720] = [__v_16, __v_53]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_16, __v_53]; 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_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -60565,7 +58568,7 @@ fn aiur_fn_731(
         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_720] = { let __args: [G; IN_720] = [__v_17, __v_63]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_17, __v_63]; 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_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -60576,7 +58579,7 @@ fn aiur_fn_731(
         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_720] = { let __args: [G; IN_720] = [__v_18, __v_73]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_18, __v_73]; 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_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -60587,17 +58590,17 @@ fn aiur_fn_731(
         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_721] = { let __args: [G; IN_721] = [__v_19, __v_83]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_19, __v_83]; 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_84: G = __r_arr[0];
         let __v_85: G = __r_arr[1];
         let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_20, __v_86]; 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 __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_20, __v_86]; 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 __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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__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[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -60607,18 +58610,18 @@ fn aiur_fn_731(
   })
 }
 
-const INPUT_SIZE_732: usize = 1;
-const IN_732: usize = 1;
-const OUT_732: usize = 63;
-fn aiur_fn_732(
-  inp: [G; IN_732],
+const INPUT_SIZE_706: usize = 1;
+const IN_706: usize = 1;
+const OUT_706: usize = 63;
+fn aiur_fn_706(
+  inp: [G; IN_706],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_732], ExecError> {
+) -> Result<[G; OUT_706], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !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_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];
@@ -60628,7 +58631,7 @@ fn aiur_fn_732(
     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_731] = { let __args: [G; IN_731] = [__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 __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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -60684,21 +58687,21 @@ fn aiur_fn_732(
     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_732] = [__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[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_706] = [__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[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_733: usize = 9;
-const IN_733: usize = 9;
-const OUT_733: usize = 2;
-fn aiur_fn_733(
-  inp: [G; IN_733],
+const INPUT_SIZE_707: usize = 9;
+const IN_707: usize = 9;
+const OUT_707: usize = 2;
+fn aiur_fn_707(
+  inp: [G; IN_707],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_733], ExecError> {
+) -> Result<[G; OUT_707], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60716,12 +58719,12 @@ fn aiur_fn_733(
         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_733] = [__v_12, __v_0];
-        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_707] = [__v_12, __v_0];
+        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; 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 __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_0]; 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60785,7 +58788,7 @@ fn aiur_fn_733(
         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_17] = { let __args: [G; IN_17] = [__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[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_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];
@@ -60794,34 +58797,34 @@ fn aiur_fn_733(
         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_733] = { let __args: [G; IN_733] = [__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[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 __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__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[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_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_733] = [__v_84, __v_82];
-        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_707] = [__v_84, __v_82];
+        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_734: usize = 1;
-const IN_734: usize = 1;
-const OUT_734: usize = 55;
-fn aiur_fn_734(
-  inp: [G; IN_734],
+const INPUT_SIZE_708: usize = 1;
+const IN_708: usize = 1;
+const OUT_708: usize = 55;
+fn aiur_fn_708(
+  inp: [G; IN_708],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_734], ExecError> {
+) -> Result<[G; OUT_708], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !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_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_76] = { let __args: [G; IN_76] = [__v_2]; 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_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];
@@ -60851,15 +58854,15 @@ fn aiur_fn_734(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; 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 __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_14, __v_33]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_14, __v_33]; 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60870,30 +58873,30 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_15, __v_43]; 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_46]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_16, __v_46]; 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_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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __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_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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_14, __v_33]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_14, __v_33]; 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60904,7 +58907,7 @@ fn aiur_fn_734(
         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_720] = { let __args: [G; IN_720] = [__v_15, __v_43]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_15, __v_43]; 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -60915,7 +58918,7 @@ fn aiur_fn_734(
         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_720] = { let __args: [G; IN_720] = [__v_16, __v_53]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_16, __v_53]; 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_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -60926,7 +58929,7 @@ fn aiur_fn_734(
         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_720] = { let __args: [G; IN_720] = [__v_17, __v_63]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_17, __v_63]; 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_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -60937,7 +58940,7 @@ fn aiur_fn_734(
         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_720] = { let __args: [G; IN_720] = [__v_18, __v_73]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_18, __v_73]; 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_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -60948,25 +58951,25 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_19, __v_83]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_19, __v_83]; 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_84: G = __r_arr[0];
         let __v_85: G = __r_arr[1];
         let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_20, __v_86]; 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 __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_20, __v_86]; 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 __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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        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 __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60977,22 +58980,22 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_14, __v_40]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14, __v_40]; 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_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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        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 __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_30]; 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -61003,18 +59006,18 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_14, __v_40]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14, __v_40]; 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_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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61025,7 +59028,7 @@ fn aiur_fn_734(
         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_720] = { let __args: [G; IN_720] = [__v_13, __v_37]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_37]; 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_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         let __v_40: G = __r_arr[2];
@@ -61036,18 +59039,18 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_14, __v_47]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14, __v_47]; 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_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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61058,18 +59061,18 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13, __v_37]; 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_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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61080,18 +59083,18 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13, __v_37]; 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_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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; 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 __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_12, __v_11]; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61102,14 +59105,14 @@ fn aiur_fn_734(
         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_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; 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 __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13, __v_37]; 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_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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
@@ -61121,7 +59124,7 @@ fn aiur_fn_734(
     break '__mc_0 [__v_30, __v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; 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_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];
@@ -61131,7 +59134,7 @@ fn aiur_fn_734(
     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_733] = { let __args: [G; IN_733] = [__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[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 __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__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[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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     break '__mc_0 [__v_37, __v_38];
@@ -61145,8 +59148,8 @@ fn aiur_fn_734(
         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_734] = [__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[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__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[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61156,18 +59159,18 @@ fn aiur_fn_734(
   })
 }
 
-const INPUT_SIZE_735: usize = 1;
-const IN_735: usize = 1;
-const OUT_735: usize = 57;
-fn aiur_fn_735(
-  inp: [G; IN_735],
+const INPUT_SIZE_709: usize = 1;
+const IN_709: usize = 1;
+const OUT_709: usize = 57;
+fn aiur_fn_709(
+  inp: [G; IN_709],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_735], ExecError> {
+) -> Result<[G; OUT_709], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_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];
@@ -61184,55 +59187,55 @@ fn aiur_fn_735(
     }
     match __v_2.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !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_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_87] = { let __args: [G; IN_87] = [__v_13]; 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_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_719] = { let __args: [G; IN_719] = [__v_15]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_15]; 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_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_735] = [__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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [__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[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !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_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_719] = { let __args: [G; IN_719] = [__v_13]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_13]; 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_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_735] = [__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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [__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[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !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_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_719] = { let __args: [G; IN_719] = [__v_13]; 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 __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_13]; 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_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_735] = [__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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [__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[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !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_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_734] = { let __args: [G; IN_734] = [__v_13]; 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 __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_13]; 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = __r_arr[2];
@@ -61289,21 +59292,21 @@ fn aiur_fn_735(
         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_735] = [__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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [__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[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !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_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_87] = { let __args: [G; IN_87] = [__v_13]; 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_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_735] = [__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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [__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[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61313,15 +59316,15 @@ fn aiur_fn_735(
   })
 }
 
-const INPUT_SIZE_736: usize = 32;
-const IN_736: usize = 32;
-const OUT_736: usize = 56;
-fn aiur_fn_736(
-  inp: [G; IN_736],
+const INPUT_SIZE_710: usize = 32;
+const IN_710: usize = 32;
+const OUT_710: usize = 56;
+fn aiur_fn_710(
+  inp: [G; IN_710],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_736], 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];
@@ -61362,8 +59365,8 @@ fn aiur_fn_736(
     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_22] = { let __args: [G; IN_22] = [__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[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_735] = { let __args: [G; IN_735] = [__v_36]; 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 __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_709] = { let __args: [G; IN_709] = [__v_36]; 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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     let __v_39: G = __r_arr[2];
@@ -61436,21 +59439,21 @@ fn aiur_fn_736(
     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_736] = [__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[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_710] = [__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[710].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 = 1;
-fn aiur_fn_737(
-  inp: [G; IN_737],
+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_737], ExecError> {
+) -> Result<[G; OUT_711], 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 };
@@ -61475,44 +59478,44 @@ fn aiur_fn_737(
     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_35] = { let __args: [G; IN_35] = [__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[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_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_23] = { let __args: [G; IN_23] = [__v_22]; 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_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_737] = [__v_23];
-    record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_711] = [__v_23];
+    record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_738: usize = 1;
-const IN_738: usize = 1;
-const OUT_738: usize = 1;
-fn aiur_fn_738(
-  inp: [G; IN_738],
+const INPUT_SIZE_712: usize = 1;
+const IN_712: usize = 1;
+const OUT_712: usize = 1;
+fn aiur_fn_712(
+  inp: [G; IN_712],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_738], ExecError> {
+) -> Result<[G; OUT_712], 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_738] = [__v_1];
-        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_712] = [__v_1];
+        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_738] = [__v_1];
-        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_712] = [__v_1];
+        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_738] = [__v_1];
-        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_712] = [__v_1];
+        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61522,35 +59525,35 @@ fn aiur_fn_738(
   })
 }
 
-const INPUT_SIZE_739: usize = 3;
-const IN_739: usize = 3;
-const OUT_739: usize = 0;
-fn aiur_fn_739(
-  inp: [G; IN_739],
+const INPUT_SIZE_713: usize = 3;
+const IN_713: usize = 3;
+const OUT_713: usize = 0;
+fn aiur_fn_713(
+  inp: [G; IN_713],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_739], 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 __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_739] = [];
-        record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; 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 __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_0]; 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; 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 __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__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 __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_739] = [];
-        record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61560,35 +59563,35 @@ fn aiur_fn_739(
   })
 }
 
-const INPUT_SIZE_740: usize = 3;
-const IN_740: usize = 3;
-const OUT_740: usize = 0;
-fn aiur_fn_740(
-  inp: [G; IN_740],
+const INPUT_SIZE_714: usize = 3;
+const IN_714: usize = 3;
+const OUT_714: usize = 0;
+fn aiur_fn_714(
+  inp: [G; IN_714],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_740], ExecError> {
+) -> Result<[G; OUT_714], ExecError> {
   stacker::maybe_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_740] = [];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_714] = [];
+        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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_100] = { let __args: [G; IN_100] = [__v_2]; 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_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 __ret: [G; OUT_740] = [];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_714] = [];
+        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61598,31 +59601,31 @@ fn aiur_fn_740(
   })
 }
 
-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_715: usize = 3;
+const IN_715: usize = 3;
+const OUT_715: usize = 0;
+fn aiur_fn_715(
+  inp: [G; IN_715],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_741], 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];
     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));
+        let __ret: [G; OUT_715] = [];
+        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       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_741] = [];
-        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_715] = [];
+        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61632,15 +59635,15 @@ fn aiur_fn_741(
   })
 }
 
-const INPUT_SIZE_742: usize = 17;
-const IN_742: usize = 17;
-const OUT_742: usize = 0;
-fn aiur_fn_742(
-  inp: [G; IN_742],
+const INPUT_SIZE_716: usize = 17;
+const IN_716: usize = 17;
+const OUT_716: usize = 0;
+fn aiur_fn_716(
+  inp: [G; IN_716],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_742], ExecError> {
+) -> Result<[G; OUT_716], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61661,8 +59664,8 @@ fn aiur_fn_742(
     let __v_16: G = inp[16];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_742] = [];
-        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_716] = [];
+        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -61690,8 +59693,8 @@ fn aiur_fn_742(
         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_742] = [];
-        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_716] = [];
+        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61701,23 +59704,23 @@ fn aiur_fn_742(
   })
 }
 
-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_717: usize = 3;
+const IN_717: usize = 3;
+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_743], ExecError> {
+) -> 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];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_743] = [];
-        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_717] = [];
+        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -61883,8 +59886,8 @@ fn aiur_fn_743(
         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_743] = [];
-        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_717] = [];
+        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61894,27 +59897,27 @@ fn aiur_fn_743(
   })
 }
 
-const INPUT_SIZE_744: usize = 3;
-const IN_744: usize = 3;
-const OUT_744: usize = 0;
-fn aiur_fn_744(
-  inp: [G; IN_744],
+const INPUT_SIZE_718: usize = 3;
+const IN_718: usize = 3;
+const OUT_718: usize = 0;
+fn aiur_fn_718(
+  inp: [G; IN_718],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_744], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_744] = [];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_718] = [];
+        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; 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 __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 __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];
@@ -62078,8 +60081,8 @@ fn aiur_fn_744(
         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_744] = [];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_718] = [];
+        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62089,15 +60092,15 @@ fn aiur_fn_744(
   })
 }
 
-const INPUT_SIZE_745: usize = 2;
-const IN_745: usize = 2;
-const OUT_745: usize = 0;
-fn aiur_fn_745(
-  inp: [G; IN_745],
+const INPUT_SIZE_719: usize = 2;
+const IN_719: usize = 2;
+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_745], ExecError> {
+) -> 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];
@@ -62137,8 +60140,8 @@ fn aiur_fn_745(
         let __v_31: G = __loaded[10];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_745] = [];
-            record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_719] = [];
+            record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -62166,7 +60169,7 @@ fn aiur_fn_745(
                 match __v_22.as_canonical_u64() {
                   _ => {
                     let __v_32: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_30, __v_32, __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_718] = { let __args: [G; IN_718] = [__v_30, __v_32, __v_19]; 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)? } };
                     if (__v_22 != __v_11) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
                     }
@@ -62191,9 +60194,9 @@ fn aiur_fn_745(
                     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_745] = { let __args: [G; IN_745] = [__v_31, __v_20]; 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_745] = [];
-                    record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_31, __v_20]; 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_719] = [];
+                    record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -62212,29 +60215,29 @@ fn aiur_fn_745(
   })
 }
 
-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_720: usize = 3;
+const IN_720: usize = 3;
+const OUT_720: usize = 0;
+fn aiur_fn_720(
+  inp: [G; IN_720],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_746], 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 __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_746] = [];
-        record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_720] = [];
+        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_2]; 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_746] = [];
-        record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_2]; 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_720] = [];
+        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62244,15 +60247,15 @@ fn aiur_fn_746(
   })
 }
 
-const INPUT_SIZE_747: usize = 49;
-const IN_747: usize = 49;
-const OUT_747: usize = 0;
-fn aiur_fn_747(
-  inp: [G; IN_747],
+const INPUT_SIZE_721: usize = 49;
+const IN_721: usize = 49;
+const OUT_721: usize = 0;
+fn aiur_fn_721(
+  inp: [G; IN_721],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_747], 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];
@@ -62303,7 +60306,7 @@ fn aiur_fn_747(
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
     let __v_48: G = inp[48];
-    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__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[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 __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__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[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 __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
     let __v_51: G = __r_arr[2];
@@ -62342,14 +60345,14 @@ fn aiur_fn_747(
       _ => {
         match __v_49.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_49, __v_9, __v_10]; 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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_82, __v_47, __v_48]; 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 __ret: [G; OUT_747] = [];
-            record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_49, __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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_721] = [];
+            record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -62358,15 +60361,15 @@ fn aiur_fn_747(
   })
 }
 
-const INPUT_SIZE_748: usize = 2;
-const IN_748: usize = 2;
-const OUT_748: usize = 0;
-fn aiur_fn_748(
-  inp: [G; IN_748],
+const INPUT_SIZE_722: usize = 2;
+const IN_722: usize = 2;
+const OUT_722: usize = 0;
+fn aiur_fn_722(
+  inp: [G; IN_722],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_748], 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];
@@ -62423,15 +60426,15 @@ fn aiur_fn_748(
     let __v_51: G = __loaded[49];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_748] = [];
-        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_722] = [];
+        record.function_queries[722].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_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[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 __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_51]; 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_748] = [];
-        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__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[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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __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 __ret: [G; OUT_722] = [];
+        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62441,29 +60444,29 @@ fn aiur_fn_748(
   })
 }
 
-const INPUT_SIZE_749: usize = 3;
-const IN_749: usize = 3;
-const OUT_749: usize = 0;
-fn aiur_fn_749(
-  inp: [G; IN_749],
+const INPUT_SIZE_723: usize = 3;
+const IN_723: usize = 3;
+const OUT_723: usize = 0;
+fn aiur_fn_723(
+  inp: [G; IN_723],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_749], ExecError> {
+) -> Result<[G; OUT_723], ExecError> {
   stacker::maybe_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_749] = [];
-        record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [];
+        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_2]; 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_749] = [];
-        record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __ret: [G; OUT_723] = [];
+        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62473,15 +60476,15 @@ fn aiur_fn_749(
   })
 }
 
-const INPUT_SIZE_750: usize = 99;
-const IN_750: usize = 99;
-const OUT_750: usize = 0;
-fn aiur_fn_750(
-  inp: [G; IN_750],
+const INPUT_SIZE_724: usize = 99;
+const IN_724: usize = 99;
+const OUT_724: usize = 0;
+fn aiur_fn_724(
+  inp: [G; IN_724],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_750], 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];
@@ -62588,13 +60591,13 @@ fn aiur_fn_750(
           0u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_1, __v_46, __v_47]; 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 __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_2, __v_48, __v_49]; 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 __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[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_11, __v_59, __v_60]; 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_12, __v_61, __v_62]; 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 __ret: [G; OUT_750] = [];
-                record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_46, __v_47]; 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_713] = { let __args: [G; IN_713] = [__v_2, __v_48, __v_49]; 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_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_59, __v_60]; 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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_724] = [];
+                record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -62609,14 +60612,14 @@ fn aiur_fn_750(
           1u64 => {
             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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_26, __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_749] = { let __args: [G; IN_749] = [__v_27, __v_77, __v_78]; 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 __ret: [G; OUT_750] = [];
-                record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_1, __v_46, __v_47]; 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_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_26, __v_75, __v_76]; 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 __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_27, __v_77, __v_78]; 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 __ret: [G; OUT_724] = [];
+                record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -62631,17 +60634,17 @@ fn aiur_fn_750(
           2u64 => {
             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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_43, __v_95, __v_96]; 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_44, __v_97, __v_98]; 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_750] = [];
-                record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_1, __v_46, __v_47]; 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_715] = { let __args: [G; IN_715] = [__v_2, __v_48, __v_49]; 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_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_43, __v_95, __v_96]; 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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_44, __v_97, __v_98]; 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_724] = [];
+                record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -62658,15 +60661,15 @@ fn aiur_fn_750(
   })
 }
 
-const INPUT_SIZE_751: usize = 2;
-const IN_751: usize = 2;
-const OUT_751: usize = 0;
-fn aiur_fn_751(
-  inp: [G; IN_751],
+const INPUT_SIZE_725: usize = 2;
+const IN_725: usize = 2;
+const OUT_725: usize = 0;
+fn aiur_fn_725(
+  inp: [G; IN_725],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_751], ExecError> {
+) -> 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];
@@ -62737,12 +60740,12 @@ fn aiur_fn_751(
     let __v_65: G = __loaded[63];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_751] = [];
-        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_725] = [];
+        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__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[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 __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__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[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_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -62788,10 +60791,10 @@ fn aiur_fn_751(
         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_750] = { let __args: [G; IN_750] = [__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[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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_65]; 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_751] = [];
-        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__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[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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0, __v_65]; 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 __ret: [G; OUT_725] = [];
+        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62801,91 +60804,91 @@ fn aiur_fn_751(
   })
 }
 
-const INPUT_SIZE_752: usize = 1;
-const IN_752: usize = 1;
-const OUT_752: usize = 1;
-fn aiur_fn_752(
-  inp: [G; IN_752],
+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_752], ExecError> {
+) -> Result<[G; OUT_726], 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_47] = { let __args: [G; IN_47] = [__v_0, __v_3]; 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_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_23] = { let __args: [G; IN_23] = [__v_7]; 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_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_752] = [__v_8];
-    record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_726] = [__v_8];
+    record.function_queries[726].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 = 1;
-fn aiur_fn_753(
-  inp: [G; IN_753],
+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_753], ExecError> {
+) -> 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];
     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_47] = { let __args: [G; IN_47] = [__v_1, __v_4]; 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_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_47] = { let __args: [G; IN_47] = [__v_0, __v_5]; 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_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_23] = { let __args: [G; IN_23] = [__v_9]; 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_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_753] = [__v_10];
-    record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_727] = [__v_10];
+    record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_754: usize = 1;
-const IN_754: usize = 1;
-const OUT_754: usize = 3;
-fn aiur_fn_754(
-  inp: [G; IN_754],
+const INPUT_SIZE_728: usize = 1;
+const IN_728: usize = 1;
+const OUT_728: usize = 3;
+fn aiur_fn_728(
+  inp: [G; IN_728],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_754], ExecError> {
+) -> Result<[G; OUT_728], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !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_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];
     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_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_752] = { let __args: [G; IN_752] = [__v_3]; 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_726] = { let __args: [G; IN_726] = [__v_3]; 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_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_754] = [__v_5, __v_10, __v_4];
-        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_728] = [__v_5, __v_10, __v_4];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -62925,25 +60928,25 @@ fn aiur_fn_754(
         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_754] = [__v_35, __v_38, __v_2];
-        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_728] = [__v_35, __v_38, __v_2];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_2]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2]; 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
-        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_5]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = __r_arr[2];
-        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_3, __v_6]; 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 __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_3, __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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_4, __v_7]; 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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_754] = [__v_9, __v_10, __v_8];
-        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_728] = [__v_9, __v_10, __v_8];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62953,15 +60956,15 @@ fn aiur_fn_754(
   })
 }
 
-const INPUT_SIZE_755: usize = 1;
-const IN_755: usize = 1;
-const OUT_755: usize = 1;
-fn aiur_fn_755(
-  inp: [G; IN_755],
+const INPUT_SIZE_729: usize = 1;
+const IN_729: usize = 1;
+const OUT_729: usize = 1;
+fn aiur_fn_729(
+  inp: [G; IN_729],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_755], ExecError> {
+) -> Result<[G; OUT_729], 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 };
@@ -63004,7 +61007,7 @@ fn aiur_fn_755(
     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_78] = { let __args: [G; IN_78] = [__v_37]; 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_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];
@@ -63015,7 +61018,7 @@ fn aiur_fn_755(
     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_754] = { let __args: [G; IN_754] = [__v_47]; 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_47]; 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_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
     let __v_50: G = __r_arr[2];
@@ -63171,21 +61174,21 @@ fn aiur_fn_755(
     if (__v_82 != __v_32) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
     }
-    let __ret: [G; OUT_755] = [__v_49];
-    record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_729] = [__v_49];
+    record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_756: usize = 2;
-const IN_756: usize = 2;
-const OUT_756: usize = 1;
-fn aiur_fn_756(
-  inp: [G; IN_756],
+const INPUT_SIZE_730: usize = 2;
+const IN_730: usize = 2;
+const OUT_730: usize = 1;
+fn aiur_fn_730(
+  inp: [G; IN_730],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_756], 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];
@@ -63196,25 +61199,25 @@ fn aiur_fn_756(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_756] = [__v_5];
-        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_730] = [__v_5];
+        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __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 __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_756] = [__v_6];
-            record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_730] = [__v_6];
+            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0, __v_4]; 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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0, __v_4]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_756] = [__v_6];
-            record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_730] = [__v_6];
+            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -63226,15 +61229,15 @@ fn aiur_fn_756(
   })
 }
 
-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_731: usize = 1;
+const IN_731: usize = 1;
+const OUT_731: usize = 1;
+fn aiur_fn_731(
+  inp: [G; IN_731],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_757], ExecError> {
+) -> Result<[G; OUT_731], 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 };
@@ -63279,21 +61282,21 @@ fn aiur_fn_757(
     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_757] = [__v_41];
-    record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_731] = [__v_41];
+    record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_758: usize = 7;
-const IN_758: usize = 7;
-const OUT_758: usize = 6;
-fn aiur_fn_758(
-  inp: [G; IN_758],
+const INPUT_SIZE_732: usize = 7;
+const IN_732: usize = 7;
+const OUT_732: usize = 6;
+fn aiur_fn_732(
+  inp: [G; IN_732],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_758], ExecError> {
+) -> Result<[G; OUT_732], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63308,29 +61311,29 @@ fn aiur_fn_758(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_758] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_732] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
+        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_8]; 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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_8]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_758] = { let __args: [G; IN_758] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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_758] = { let __args: [G; IN_758] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_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_758] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_732] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63340,15 +61343,15 @@ fn aiur_fn_758(
   })
 }
 
-const INPUT_SIZE_759: usize = 7;
-const IN_759: usize = 7;
-const OUT_759: usize = 1;
-fn aiur_fn_759(
-  inp: [G; IN_759],
+const INPUT_SIZE_733: usize = 7;
+const IN_733: usize = 7;
+const OUT_733: usize = 1;
+fn aiur_fn_733(
+  inp: [G; IN_733],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_759], ExecError> {
+) -> Result<[G; OUT_733], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63357,7 +61360,7 @@ fn aiur_fn_759(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0]; 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_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
@@ -63392,34 +61395,34 @@ fn aiur_fn_759(
     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 __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; 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_747] = { let __args: [G; IN_747] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; 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 __v_41: G = __r_arr[0];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_41, __v_0]; 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_41, __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_42: G = __r_arr[0];
-    let __ret: [G; OUT_759] = [__v_42];
-    record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_733] = [__v_42];
+    record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_760: usize = 4;
-const IN_760: usize = 4;
-const OUT_760: usize = 0;
-fn aiur_fn_760(
-  inp: [G; IN_760],
+const INPUT_SIZE_734: usize = 4;
+const IN_734: usize = 4;
+const OUT_734: usize = 0;
+fn aiur_fn_734(
+  inp: [G; IN_734],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_760], ExecError> {
+) -> Result<[G; OUT_734], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __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_682] = { let __args: [G; IN_682] = [__v_1, __v_2]; 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 __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_1, __v_2]; 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_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(1);
-    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; 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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -63427,22 +61430,22 @@ fn aiur_fn_760(
     let __v_10: G = __r_arr[4];
     let __v_11: G = __r_arr[5];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_760] = [];
-    record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 __ret: [G; OUT_734] = [];
+    record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_761: usize = 10;
-const IN_761: usize = 10;
-const OUT_761: usize = 0;
-fn aiur_fn_761(
-  inp: [G; IN_761],
+const INPUT_SIZE_735: usize = 10;
+const IN_735: usize = 10;
+const OUT_735: usize = 0;
+fn aiur_fn_735(
+  inp: [G; IN_735],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_761], ExecError> {
+) -> Result<[G; OUT_735], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63460,8 +61463,8 @@ fn aiur_fn_761(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_761] = [];
-        record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_735] = [];
+        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -63477,26 +61480,26 @@ fn aiur_fn_761(
         let __v_21: G = __loaded[8];
         let __v_22: G = __loaded[9];
         let __v_23: G = __loaded[10];
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_9]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_2, __v_9]; 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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_733] = { let __args: [G; IN_733] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_25: G = __r_arr[0];
         match __v_25.as_canonical_u64() {
           1u64 => {
             let __v_26: G = G::from_u64(1);
             let __v_27: G = (__v_9 + __v_26);
-            let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; 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_761] = [];
-            record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; 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 __ret: [G; OUT_735] = [];
+            record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __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 __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __v_1, __v_2]; 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 __v_26: G = G::from_u64(1);
             let __v_27: G = (__v_9 + __v_26);
-            let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; 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_761] = [];
-            record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; 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 __ret: [G; OUT_735] = [];
+            record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -63508,35 +61511,35 @@ fn aiur_fn_761(
   })
 }
 
-const INPUT_SIZE_762: usize = 3;
-const IN_762: usize = 3;
-const OUT_762: usize = 0;
-fn aiur_fn_762(
-  inp: [G; IN_762],
+const INPUT_SIZE_736: usize = 3;
+const IN_736: usize = 3;
+const OUT_736: usize = 0;
+fn aiur_fn_736(
+  inp: [G; IN_736],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_762], ExecError> {
+) -> Result<[G; OUT_736], ExecError> {
   stacker::maybe_grow(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_195] = { let __args: [G; IN_195] = [__v_0]; 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 __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_717] = { let __args: [G; IN_717] = [__v_3, __v_3, __v_4]; 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_762] = [];
-        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_3, __v_3, __v_4]; 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_736] = [];
+        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_2]; 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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_762] = [];
-        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_3, __v_3, __v_4, __v_5]; 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 __ret: [G; OUT_736] = [];
+        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63546,63 +61549,63 @@ fn aiur_fn_762(
   })
 }
 
-const INPUT_SIZE_763: usize = 2;
-const IN_763: usize = 2;
-const OUT_763: usize = 0;
-fn aiur_fn_763(
-  inp: [G; IN_763],
+const INPUT_SIZE_737: usize = 2;
+const IN_737: usize = 2;
+const OUT_737: usize = 0;
+fn aiur_fn_737(
+  inp: [G; IN_737],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_763], ExecError> {
+) -> Result<[G; OUT_737], 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_755] = { let __args: [G; IN_755] = [__v_0]; 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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_1, __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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_1, __v_2]; 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_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 __ret: [G; OUT_763] = [];
-    record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_737] = [];
+    record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_764: usize = 3;
-const IN_764: usize = 3;
-const OUT_764: usize = 0;
-fn aiur_fn_764(
-  inp: [G; IN_764],
+const INPUT_SIZE_738: usize = 3;
+const IN_738: usize = 3;
+const OUT_738: usize = 0;
+fn aiur_fn_738(
+  inp: [G; IN_738],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_764], ExecError> {
+) -> Result<[G; OUT_738], ExecError> {
   stacker::maybe_grow(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_755] = { let __args: [G; IN_755] = [__v_0]; 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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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 __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() {
       1u64 => {
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_4, __v_5]; 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_764] = [];
-        record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_4, __v_4, __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 __ret: [G; OUT_738] = [];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_2]; 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 __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4, __v_4, __v_5, __v_6]; 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 __ret: [G; OUT_764] = [];
-        record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_4, __v_4, __v_5, __v_6]; 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 __ret: [G; OUT_738] = [];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63612,15 +61615,15 @@ fn aiur_fn_764(
   })
 }
 
-const INPUT_SIZE_765: usize = 55;
-const IN_765: usize = 55;
-const OUT_765: usize = 0;
-fn aiur_fn_765(
-  inp: [G; IN_765],
+const INPUT_SIZE_739: usize = 55;
+const IN_739: usize = 55;
+const OUT_739: usize = 0;
+fn aiur_fn_739(
+  inp: [G; IN_739],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_765], ExecError> {
+) -> Result<[G; OUT_739], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63677,7 +61680,7 @@ fn aiur_fn_765(
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
     let __v_54: G = inp[54];
-    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0]; 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 __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_55: G = __r_arr[0];
     let __v_56: G = __r_arr[1];
     let __v_57: G = __r_arr[2];
@@ -63734,13 +61737,13 @@ fn aiur_fn_765(
               0u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_57, __v_4, __v_5]; 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 __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[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_66, __v_15, __v_16]; 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_67, __v_17, __v_18]; 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 __ret: [G; OUT_765] = [];
-                    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_56, __v_2, __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 __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_57, __v_4, __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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_66, __v_15, __v_16]; 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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63755,17 +61758,17 @@ fn aiur_fn_765(
               1u64 => {
                 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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_98, __v_51, __v_52]; 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_99, __v_53, __v_54]; 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_765] = [];
-                    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_56, __v_2, __v_3]; 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_715] = { let __args: [G; IN_715] = [__v_57, __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_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_98, __v_51, __v_52]; 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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_99, __v_53, __v_54]; 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_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63780,11 +61783,11 @@ fn aiur_fn_765(
               2u64 => {
                 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_742] = { let __args: [G; IN_742] = [__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[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_65, __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 __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_56, __v_2, __v_3]; 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_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63799,11 +61802,11 @@ fn aiur_fn_765(
               3u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_2, __v_3]; 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 __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[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_65, __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 __ret: [G; OUT_765] = [];
-                    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_56, __v_2, __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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63818,11 +61821,11 @@ fn aiur_fn_765(
               4u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[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_742] = { let __args: [G; IN_742] = [__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[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_743] = { let __args: [G; IN_743] = [__v_72, __v_20, __v_21]; 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 __ret: [G; OUT_765] = [];
-                    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_72, __v_20, __v_21]; 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_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63837,10 +61840,10 @@ fn aiur_fn_765(
               5u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[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_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_765] = [];
-                    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_64, __v_11, __v_12]; 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_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63855,10 +61858,10 @@ fn aiur_fn_765(
               6u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[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_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_765] = [];
-                    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_64, __v_11, __v_12]; 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_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63873,10 +61876,10 @@ fn aiur_fn_765(
               7u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[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_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; 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 __ret: [G; OUT_765] = [];
-                    record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[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 __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_64, __v_11, __v_12]; 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_739] = [];
+                    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -63889,9 +61892,9 @@ fn aiur_fn_765(
           8u64 => {
             match __v_1.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_56, __v_2]; 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_765] = [];
-                record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_56, __v_2]; 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 __ret: [G; OUT_739] = [];
+                record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -63908,15 +61911,15 @@ fn aiur_fn_765(
   })
 }
 
-const INPUT_SIZE_766: usize = 4;
-const IN_766: usize = 4;
-const OUT_766: usize = 0;
-fn aiur_fn_766(
-  inp: [G; IN_766],
+const INPUT_SIZE_740: usize = 4;
+const IN_740: usize = 4;
+const OUT_740: usize = 0;
+fn aiur_fn_740(
+  inp: [G; IN_740],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_766], ExecError> {
+) -> Result<[G; OUT_740], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63927,21 +61930,21 @@ fn aiur_fn_766(
     if (__v_4 != __v_5) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
     }
-    let __ret: [G; OUT_766] = [];
-    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_740] = [];
+    record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_767: usize = 32;
-const IN_767: usize = 32;
-const OUT_767: usize = 0;
-fn aiur_fn_767(
-  inp: [G; IN_767],
+const INPUT_SIZE_741: usize = 32;
+const IN_741: usize = 32;
+const OUT_741: usize = 0;
+fn aiur_fn_741(
+  inp: [G; IN_741],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_767], ExecError> {
+) -> Result<[G; OUT_741], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63975,7 +61978,7 @@ fn aiur_fn_767(
     let __v_29: G = inp[29];
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
-    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__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[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 __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__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[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 = __r_arr[1];
     let __v_34: G = __r_arr[2];
@@ -64034,33 +62037,33 @@ fn aiur_fn_767(
     let __v_87: G = __r_arr[55];
     match __v_32.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_33, __v_34, __v_35, __v_36]; 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_767] = [];
-        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_33, __v_34, __v_35, __v_36]; 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 __ret: [G; OUT_741] = [];
+        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33, __v_34, __v_35]; 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_767] = [];
-        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_33, __v_34, __v_35]; 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 __ret: [G; OUT_741] = [];
+        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_33, __v_34, __v_35]; 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_767] = [];
-        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_33, __v_34, __v_35]; 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 __ret: [G; OUT_741] = [];
+        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__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[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_767] = [];
-        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__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[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 __ret: [G; OUT_741] = [];
+        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_33, __v_34]; 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_767] = [];
-        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_33, __v_34]; 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 __ret: [G; OUT_741] = [];
+        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64070,15 +62073,15 @@ fn aiur_fn_767(
   })
 }
 
-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_742: usize = 32;
+const IN_742: usize = 32;
+const OUT_742: usize = 0;
+fn aiur_fn_742(
+  inp: [G; IN_742],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_768], ExecError> {
+) -> Result<[G; OUT_742], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64113,13 +62116,13 @@ fn aiur_fn_768(
     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_195] = { let __args: [G; IN_195] = [__v_32]; 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 __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_469] = { let __args: [G; IN_469] = [__v_32, __v_34, __v_35]; 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 __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_32, __v_34, __v_35]; 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_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_33, __v_36]; 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 __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_33, __v_36]; 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 __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];
@@ -64133,566 +62136,22 @@ fn aiur_fn_768(
     let __v_46: G = __loaded[8];
     let __v_47: G = __loaded[9];
     let __v_48: G = __loaded[10];
-    let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__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[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_768] = [];
-    record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__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[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_742] = [];
+    record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_769: usize = 1;
-const IN_769: usize = 1;
-const OUT_769: usize = 0;
-fn aiur_fn_769(
-  inp: [G; IN_769],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_769], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_769] = [];
-        record.function_queries[769].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 __v_3: G = G::from_u64(0);
-        let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-        let __v_4: G = __io_pair.0;
-        let __v_5: G = __io_pair.1;
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; 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_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 __v_20: G = __r_arr[12];
-        let __v_21: G = __r_arr[13];
-        let __v_22: G = __r_arr[14];
-        let __v_23: G = __r_arr[15];
-        let __v_24: G = __r_arr[16];
-        let __v_25: G = __r_arr[17];
-        let __v_26: G = __r_arr[18];
-        let __v_27: G = __r_arr[19];
-        let __v_28: G = __r_arr[20];
-        let __v_29: G = __r_arr[21];
-        let __v_30: G = __r_arr[22];
-        let __v_31: G = __r_arr[23];
-        let __v_32: G = __r_arr[24];
-        let __v_33: G = __r_arr[25];
-        let __v_34: G = __r_arr[26];
-        let __v_35: G = __r_arr[27];
-        let __v_36: G = __r_arr[28];
-        let __v_37: G = __r_arr[29];
-        let __v_38: G = __r_arr[30];
-        let __v_39: G = __r_arr[31];
-        let __v_40: G = __r_arr[32];
-        let __v_41: G = __r_arr[33];
-        let __v_42: G = __r_arr[34];
-        let __v_43: G = __r_arr[35];
-        let __v_44: G = __r_arr[36];
-        let __v_45: G = __r_arr[37];
-        let __v_46: G = __r_arr[38];
-        let __v_47: G = __r_arr[39];
-        let __v_48: G = __r_arr[40];
-        let __v_49: G = __r_arr[41];
-        let __v_50: G = __r_arr[42];
-        let __v_51: G = __r_arr[43];
-        let __v_52: G = __r_arr[44];
-        let __v_53: G = __r_arr[45];
-        let __v_54: G = __r_arr[46];
-        let __v_55: G = __r_arr[47];
-        let __v_56: G = __r_arr[48];
-        let __v_57: G = G::from_u64(1);
-        let __v_58: G = G::from_u64(1);
-        let __v_59: G = { let __values: [G; 3] = [__v_57, __v_58, __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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__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, __v_59]; 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_60: 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_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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_61: G = __loaded[0];
-        let __v_62: G = __loaded[1];
-        let __v_63: G = __loaded[2];
-        let __v_64: G = G::from_u64(1);
-        let __v_65: G = G::from_u64(1);
-        if (__v_61 != __v_64) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_64.as_canonical_u64() });
-        }
-        if (__v_62 != __v_65) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
-        }
-        if (__v_63 != __v_65) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
-        }
-        if (__v_7 != __v_60) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_769] = [];
-        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_770: usize = 0;
-const IN_770: usize = 0;
-const OUT_770: usize = 0;
-fn aiur_fn_770(
-  inp: [G; IN_770],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_770], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(0);
-    let __v_2: G = { let __values: [G; 3] = [__v_0, __v_1, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_3: G = G::from_u64(4);
-    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_3, __v_4, __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(4);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __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(0);
-    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_6, __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(0);
-    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_2, __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(2);
-    let __v_18: G = { let __values: [G; 3] = [__v_17, __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 __v_19: G = G::from_u64(3);
-    let __v_20: G = { let __values: [G; 3] = [__v_19, __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 __v_21: G = G::from_u64(2);
-    let __v_22: G = G::from_u64(3);
-    let __v_23: G = { let __values: [G; 3] = [__v_22, __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 __v_24: G = { let __values: [G; 3] = [__v_21, __v_16, __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(0);
-    let __v_27: G = { let __values: [G; 3] = [__v_25, __v_10, __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_228] = { let __args: [G; IN_228] = [__v_2, __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_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() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __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_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() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_10]; 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 __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_228] = { let __args: [G; IN_228] = [__v_13, __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_34: G = __r_arr[0];
-    let __v_35: G = G::from_u64(1);
-    if (__v_34 != __v_35) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_13, __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_36: G = __r_arr[0];
-    let __v_37: G = G::from_u64(0);
-    if (__v_36 != __v_37) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_37.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __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_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() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_18, __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_40: G = __r_arr[0];
-    let __v_41: G = G::from_u64(1);
-    if (__v_40 != __v_41) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __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_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() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_18, __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 = G::from_u64(0);
-    if (__v_44 != __v_45) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_20, __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_46: G = __r_arr[0];
-    let __v_47: G = G::from_u64(1);
-    if (__v_46 != __v_47) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_18, __v_20]; 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_48: G = __r_arr[0];
-    let __v_49: G = G::from_u64(0);
-    if (__v_48 != __v_49) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_49.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_24]; 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_50: G = __r_arr[0];
-    let __v_51: G = G::from_u64(1);
-    if (__v_50 != __v_51) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_51.as_canonical_u64() });
-    }
-    let __v_52: G = G::from_u64(3);
-    let __v_53: G = { let __values: [G; 3] = [__v_52, __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_229] = { let __args: [G; IN_229] = [__v_53, __v_6]; 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_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() });
-    }
-    let __v_56: G = G::from_u64(2);
-    let __v_57: G = { let __values: [G; 3] = [__v_56, __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_229] = { let __args: [G; IN_229] = [__v_57, __v_6]; 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_58: G = __r_arr[0];
-    let __v_59: G = G::from_u64(1);
-    if (__v_58 != __v_59) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_27]; 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_60: G = __r_arr[0];
-    let __v_61: G = G::from_u64(2);
-    let __v_62: G = { let __values: [G; 3] = [__v_61, __v_6, __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 __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_60, __v_62]; 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_63: G = __r_arr[0];
-    let __v_64: G = G::from_u64(1);
-    if (__v_63 != __v_64) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_2]; 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_65: G = __r_arr[0];
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_65, __v_2]; 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_66: G = __r_arr[0];
-    let __v_67: G = G::from_u64(1);
-    if (__v_66 != __v_67) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64() });
-    }
-    let __ret: [G; OUT_770] = [];
-    record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_771: usize = 0;
-const IN_771: usize = 0;
-const OUT_771: usize = 0;
-fn aiur_fn_771(
-  inp: [G; IN_771],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_771], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = []; 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 __ret: [G; OUT_771] = [];
-    record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_772: usize = 1;
-const IN_772: usize = 1;
-const OUT_772: usize = 0;
-fn aiur_fn_772(
-  inp: [G; IN_772],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_772], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_772] = [];
-        record.function_queries[772].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 __v_3: G = G::from_u64(0);
-        let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-        let __v_4: G = __io_pair.0;
-        let __v_5: G = __io_pair.1;
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; 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_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 __v_20: G = __r_arr[12];
-        let __v_21: G = __r_arr[13];
-        let __v_22: G = __r_arr[14];
-        let __v_23: G = __r_arr[15];
-        let __v_24: G = __r_arr[16];
-        let __v_25: G = __r_arr[17];
-        let __v_26: G = __r_arr[18];
-        let __v_27: G = __r_arr[19];
-        let __v_28: G = __r_arr[20];
-        let __v_29: G = __r_arr[21];
-        let __v_30: G = __r_arr[22];
-        let __v_31: G = __r_arr[23];
-        let __v_32: G = __r_arr[24];
-        let __v_33: G = __r_arr[25];
-        let __v_34: G = __r_arr[26];
-        let __v_35: G = __r_arr[27];
-        let __v_36: G = __r_arr[28];
-        let __v_37: G = __r_arr[29];
-        let __v_38: G = __r_arr[30];
-        let __v_39: G = __r_arr[31];
-        let __v_40: G = __r_arr[32];
-        let __v_41: G = __r_arr[33];
-        let __v_42: G = __r_arr[34];
-        let __v_43: G = __r_arr[35];
-        let __v_44: G = __r_arr[36];
-        let __v_45: G = __r_arr[37];
-        let __v_46: G = __r_arr[38];
-        let __v_47: G = __r_arr[39];
-        let __v_48: G = __r_arr[40];
-        let __v_49: G = __r_arr[41];
-        let __v_50: G = __r_arr[42];
-        let __v_51: G = __r_arr[43];
-        let __v_52: G = __r_arr[44];
-        let __v_53: G = __r_arr[45];
-        let __v_54: G = __r_arr[46];
-        let __v_55: G = __r_arr[47];
-        let __v_56: G = __r_arr[48];
-        let __v_57: G = G::from_u64(1);
-        let __v_58: G = G::from_u64(1);
-        let __v_59: G = { let __values: [G; 3] = [__v_57, __v_58, __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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__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, __v_59]; 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_60: 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_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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_61: G = __loaded[0];
-        let __v_62: G = __loaded[1];
-        let __v_63: G = __loaded[2];
-        let __v_64: G = G::from_u64(1);
-        let __v_65: G = G::from_u64(1);
-        if (__v_61 != __v_64) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_64.as_canonical_u64() });
-        }
-        if (__v_62 != __v_65) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
-        }
-        if (__v_63 != __v_65) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; 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_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 __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_60]; 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_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 = __r_arr[12];
-        let __v_111: G = __r_arr[13];
-        let __v_112: G = __r_arr[14];
-        let __v_113: G = __r_arr[15];
-        let __v_114: G = __r_arr[16];
-        let __v_115: G = __r_arr[17];
-        let __v_116: G = __r_arr[18];
-        let __v_117: G = __r_arr[19];
-        let __v_118: G = __r_arr[20];
-        let __v_119: G = __r_arr[21];
-        let __v_120: G = __r_arr[22];
-        let __v_121: G = __r_arr[23];
-        let __v_122: G = __r_arr[24];
-        let __v_123: G = __r_arr[25];
-        let __v_124: G = __r_arr[26];
-        let __v_125: G = __r_arr[27];
-        let __v_126: G = __r_arr[28];
-        let __v_127: G = __r_arr[29];
-        let __v_128: G = __r_arr[30];
-        let __v_129: G = __r_arr[31];
-        if (__v_66 != __v_98) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_98.as_canonical_u64() });
-        }
-        if (__v_67 != __v_99) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_99.as_canonical_u64() });
-        }
-        if (__v_68 != __v_100) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_100.as_canonical_u64() });
-        }
-        if (__v_69 != __v_101) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_101.as_canonical_u64() });
-        }
-        if (__v_70 != __v_102) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_102.as_canonical_u64() });
-        }
-        if (__v_71 != __v_103) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_103.as_canonical_u64() });
-        }
-        if (__v_72 != __v_104) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_104.as_canonical_u64() });
-        }
-        if (__v_73 != __v_105) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_105.as_canonical_u64() });
-        }
-        if (__v_74 != __v_106) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_106.as_canonical_u64() });
-        }
-        if (__v_75 != __v_107) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_107.as_canonical_u64() });
-        }
-        if (__v_76 != __v_108) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_108.as_canonical_u64() });
-        }
-        if (__v_77 != __v_109) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_109.as_canonical_u64() });
-        }
-        if (__v_78 != __v_110) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_110.as_canonical_u64() });
-        }
-        if (__v_79 != __v_111) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_111.as_canonical_u64() });
-        }
-        if (__v_80 != __v_112) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_112.as_canonical_u64() });
-        }
-        if (__v_81 != __v_113) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_113.as_canonical_u64() });
-        }
-        if (__v_82 != __v_114) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_114.as_canonical_u64() });
-        }
-        if (__v_83 != __v_115) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_115.as_canonical_u64() });
-        }
-        if (__v_84 != __v_116) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_116.as_canonical_u64() });
-        }
-        if (__v_85 != __v_117) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_117.as_canonical_u64() });
-        }
-        if (__v_86 != __v_118) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_118.as_canonical_u64() });
-        }
-        if (__v_87 != __v_119) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_119.as_canonical_u64() });
-        }
-        if (__v_88 != __v_120) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_120.as_canonical_u64() });
-        }
-        if (__v_89 != __v_121) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_121.as_canonical_u64() });
-        }
-        if (__v_90 != __v_122) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_122.as_canonical_u64() });
-        }
-        if (__v_91 != __v_123) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_123.as_canonical_u64() });
-        }
-        if (__v_92 != __v_124) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_92.as_canonical_u64(), rhs: __v_124.as_canonical_u64() });
-        }
-        if (__v_93 != __v_125) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_125.as_canonical_u64() });
-        }
-        if (__v_94 != __v_126) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_126.as_canonical_u64() });
-        }
-        if (__v_95 != __v_127) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_127.as_canonical_u64() });
-        }
-        if (__v_96 != __v_128) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_128.as_canonical_u64() });
-        }
-        if (__v_97 != __v_129) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_129.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2]; 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 __ret: [G; OUT_772] = [];
-        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_773: usize = 2;
-const IN_773: usize = 2;
-const OUT_773: usize = 1;
-fn aiur_fn_773(
-  inp: [G; IN_773],
+const INPUT_SIZE_743: usize = 2;
+const IN_743: usize = 2;
+const OUT_743: usize = 1;
+fn aiur_fn_743(
+  inp: [G; IN_743],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_773], ExecError> {
+) -> Result<[G; OUT_743], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64707,17 +62166,17 @@ fn aiur_fn_773(
         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_773] = [__v_9];
-        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_743] = [__v_9];
+        record.function_queries[743].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 __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_4, __v_1]; 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 __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));
+        let __ret: [G; OUT_743] = [__v_7];
+        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64727,15 +62186,15 @@ fn aiur_fn_773(
   })
 }
 
-const INPUT_SIZE_774: usize = 1;
-const IN_774: usize = 1;
-const OUT_774: usize = 8;
-fn aiur_fn_774(
-  inp: [G; IN_774],
+const INPUT_SIZE_744: usize = 1;
+const IN_744: usize = 1;
+const OUT_744: usize = 8;
+fn aiur_fn_744(
+  inp: [G; IN_744],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_774], ExecError> {
+) -> Result<[G; OUT_744], 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 };
@@ -64759,12 +62218,12 @@ fn aiur_fn_774(
         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_774] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_744] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
+        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__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 __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -64773,7 +62232,7 @@ fn aiur_fn_774(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -64782,8 +62241,8 @@ fn aiur_fn_774(
         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_774] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_744] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64793,15 +62252,15 @@ fn aiur_fn_774(
   })
 }
 
-const INPUT_SIZE_775: usize = 1;
-const IN_775: usize = 1;
-const OUT_775: usize = 8;
-fn aiur_fn_775(
-  inp: [G; IN_775],
+const INPUT_SIZE_745: usize = 1;
+const IN_745: usize = 1;
+const OUT_745: usize = 8;
+fn aiur_fn_745(
+  inp: [G; IN_745],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_775], ExecError> {
+) -> Result<[G; OUT_745], 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 };
@@ -64818,12 +62277,12 @@ fn aiur_fn_775(
         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_775] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_745] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; 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 __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_3]; 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 __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = __r_arr[2];
@@ -64832,7 +62291,7 @@ fn aiur_fn_775(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -64841,8 +62300,8 @@ fn aiur_fn_775(
         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_775] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_745] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64852,15 +62311,15 @@ fn aiur_fn_775(
   })
 }
 
-const INPUT_SIZE_776: usize = 2;
-const IN_776: usize = 2;
-const OUT_776: usize = 1;
-fn aiur_fn_776(
-  inp: [G; IN_776],
+const INPUT_SIZE_746: usize = 2;
+const IN_746: usize = 2;
+const OUT_746: usize = 1;
+fn aiur_fn_746(
+  inp: [G; IN_746],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_776], ExecError> {
+) -> Result<[G; OUT_746], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64870,17 +62329,17 @@ fn aiur_fn_776(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_776] = [__v_1];
-        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_746] = [__v_1];
+        record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_1]; 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 __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_4, __v_1]; 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 __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_776] = [__v_7];
-        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_746] = [__v_7];
+        record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64890,15 +62349,15 @@ fn aiur_fn_776(
   })
 }
 
-const INPUT_SIZE_777: usize = 8;
-const IN_777: usize = 8;
-const OUT_777: usize = 1;
-fn aiur_fn_777(
-  inp: [G; IN_777],
+const INPUT_SIZE_747: usize = 8;
+const IN_747: usize = 8;
+const OUT_747: usize = 1;
+fn aiur_fn_747(
+  inp: [G; IN_747],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_777], ExecError> {
+) -> Result<[G; OUT_747], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64910,8 +62369,8 @@ fn aiur_fn_777(
     let __v_7: G = inp[7];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_777] = [__v_7];
-        record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_747] = [__v_7];
+        record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -64932,25 +62391,25 @@ fn aiur_fn_777(
         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_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_777] = [__v_21];
-            record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_747] = [__v_21];
+            record.function_queries[747].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_777] = [__v_4];
-                record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_747] = [__v_4];
+                record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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[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_747] = { let __args: [G; IN_747] = [__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[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 __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_777] = [__v_22];
-                record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_747] = [__v_22];
+                record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -64964,15 +62423,15 @@ 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_748: usize = 2;
+const IN_748: usize = 2;
+const OUT_748: usize = 1;
+fn aiur_fn_748(
+  inp: [G; IN_748],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_778], ExecError> {
+) -> Result<[G; OUT_748], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64984,17 +62443,17 @@ fn aiur_fn_778(
     let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_778] = [__v_1];
-        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_748] = [__v_1];
+        record.function_queries[748].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_6, __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 __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_6, __v_1]; 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 __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_778] = [__v_9];
-        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_748] = [__v_9];
+        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65004,37 +62463,37 @@ fn aiur_fn_778(
   })
 }
 
-const INPUT_SIZE_779: usize = 1;
-const IN_779: usize = 1;
-const OUT_779: usize = 1;
-fn aiur_fn_779(
-  inp: [G; IN_779],
+const INPUT_SIZE_749: usize = 1;
+const IN_749: usize = 1;
+const OUT_749: usize = 1;
+fn aiur_fn_749(
+  inp: [G; IN_749],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_779], ExecError> {
+) -> Result<[G; OUT_749], 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_802] = { let __args: [G; IN_802] = [__v_0, __v_3]; 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_772] = { let __args: [G; IN_772] = [__v_0, __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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_779] = [__v_4];
-    record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_749] = [__v_4];
+    record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_780: usize = 1;
-const IN_780: usize = 1;
-const OUT_780: usize = 8;
-fn aiur_fn_780(
-  inp: [G; IN_780],
+const INPUT_SIZE_750: usize = 1;
+const IN_750: usize = 1;
+const OUT_750: usize = 8;
+fn aiur_fn_750(
+  inp: [G; IN_750],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_780], ExecError> {
+) -> Result<[G; OUT_750], 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 };
@@ -65084,12 +62543,12 @@ fn aiur_fn_780(
         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_780] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
-        record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_750] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
+        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_36]; 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_750] = { let __args: [G; IN_750] = [__v_36]; 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 __v_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -65098,7 +62557,7 @@ fn aiur_fn_780(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -65107,8 +62566,8 @@ fn aiur_fn_780(
         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_780] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
-        record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_750] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
+        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65118,19 +62577,19 @@ fn aiur_fn_780(
   })
 }
 
-const INPUT_SIZE_781: usize = 2;
-const IN_781: usize = 2;
-const OUT_781: usize = 1;
-fn aiur_fn_781(
-  inp: [G; IN_781],
+const INPUT_SIZE_751: usize = 2;
+const IN_751: usize = 2;
+const OUT_751: usize = 1;
+fn aiur_fn_751(
+  inp: [G; IN_751],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_781], ExecError> {
+) -> Result<[G; OUT_751], 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_799] = { let __args: [G; IN_799] = [__v_0, __v_1]; 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_769] = { let __args: [G; IN_769] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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];
@@ -65138,8 +62597,8 @@ fn aiur_fn_781(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_781] = [__v_4];
-        record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_751] = [__v_4];
+        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65149,15 +62608,15 @@ fn aiur_fn_781(
   })
 }
 
-const INPUT_SIZE_782: usize = 9;
-const IN_782: usize = 9;
-const OUT_782: usize = 1;
-fn aiur_fn_782(
-  inp: [G; IN_782],
+const INPUT_SIZE_752: usize = 9;
+const IN_752: usize = 9;
+const OUT_752: usize = 1;
+fn aiur_fn_752(
+  inp: [G; IN_752],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_782], ExecError> {
+) -> Result<[G; OUT_752], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65178,12 +62637,12 @@ fn aiur_fn_782(
         let __v_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_782] = [__v_10];
-            record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_752] = [__v_10];
+            record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_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];
@@ -65192,10 +62651,10 @@ fn aiur_fn_782(
             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_782] = { let __args: [G; IN_782] = [__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[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_752] = { let __args: [G; IN_752] = [__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[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 __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_782] = [__v_21];
-            record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_752] = [__v_21];
+            record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65210,15 +62669,15 @@ fn aiur_fn_782(
   })
 }
 
-const INPUT_SIZE_783: usize = 1;
-const IN_783: usize = 1;
-const OUT_783: usize = 1;
-fn aiur_fn_783(
-  inp: [G; IN_783],
+const INPUT_SIZE_753: usize = 1;
+const IN_753: usize = 1;
+const OUT_753: usize = 1;
+fn aiur_fn_753(
+  inp: [G; IN_753],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_783], ExecError> {
+) -> Result<[G; OUT_753], 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 };
@@ -65235,17 +62694,17 @@ fn aiur_fn_783(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_783] = [__v_11];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_753] = [__v_11];
+        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_10]; 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 __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_10]; 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 __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_783] = [__v_13];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_753] = [__v_13];
+        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65255,15 +62714,15 @@ fn aiur_fn_783(
   })
 }
 
-const INPUT_SIZE_784: usize = 7;
-const IN_784: usize = 7;
-const OUT_784: usize = 1;
-fn aiur_fn_784(
-  inp: [G; IN_784],
+const INPUT_SIZE_754: usize = 7;
+const IN_754: usize = 7;
+const OUT_754: usize = 1;
+fn aiur_fn_754(
+  inp: [G; IN_754],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_784], ExecError> {
+) -> Result<[G; OUT_754], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65291,25 +62750,25 @@ fn aiur_fn_784(
         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_784] = { let __args: [G; IN_784] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_754] = { let __args: [G; IN_754] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_20: G = __r_arr[0];
-            let __ret: [G; OUT_784] = [__v_20];
-            record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_754] = [__v_20];
+            record.function_queries[754].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_784] = [__v_4];
-                record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_754] = [__v_4];
+                record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_754] = { let __args: [G; IN_754] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_21: G = __r_arr[0];
-                let __ret: [G; OUT_784] = [__v_21];
-                record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_754] = [__v_21];
+                record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -65323,15 +62782,15 @@ fn aiur_fn_784(
   })
 }
 
-const INPUT_SIZE_785: usize = 9;
-const IN_785: usize = 9;
-const OUT_785: usize = 45;
-fn aiur_fn_785(
-  inp: [G; IN_785],
+const INPUT_SIZE_755: usize = 9;
+const IN_755: usize = 9;
+const OUT_755: usize = 45;
+fn aiur_fn_755(
+  inp: [G; IN_755],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_785], ExecError> {
+) -> Result<[G; OUT_755], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65396,12 +62855,12 @@ fn aiur_fn_785(
         let __v_56: G = __r_arr[0];
         match __v_56.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_785] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_755] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_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_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
             let __v_59: G = __r_arr[2];
@@ -65410,7 +62869,7 @@ fn aiur_fn_785(
             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_785] = { let __args: [G; IN_785] = [__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[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 __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__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[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_65: G = __r_arr[0];
             let __v_66: G = __r_arr[1];
             let __v_67: G = __r_arr[2];
@@ -65456,8 +62915,8 @@ fn aiur_fn_785(
             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_785] = [__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[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_755] = [__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[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65472,15 +62931,15 @@ fn aiur_fn_785(
   })
 }
 
-const INPUT_SIZE_786: usize = 2;
-const IN_786: usize = 2;
-const OUT_786: usize = 1;
-fn aiur_fn_786(
-  inp: [G; IN_786],
+const INPUT_SIZE_756: usize = 2;
+const IN_756: usize = 2;
+const OUT_756: usize = 1;
+fn aiur_fn_756(
+  inp: [G; IN_756],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_786], ExecError> {
+) -> Result<[G; OUT_756], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65493,17 +62952,17 @@ fn aiur_fn_786(
     let __v_7: G = __loaded[5];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_786] = [__v_1];
-        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_756] = [__v_1];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_7, __v_1]; 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_756] = { let __args: [G; IN_756] = [__v_7, __v_1]; 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_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_786] = [__v_10];
-        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_756] = [__v_10];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65513,15 +62972,15 @@ fn aiur_fn_786(
   })
 }
 
-const INPUT_SIZE_787: usize = 1;
-const IN_787: usize = 1;
-const OUT_787: usize = 8;
-fn aiur_fn_787(
-  inp: [G; IN_787],
+const INPUT_SIZE_757: usize = 1;
+const IN_757: usize = 1;
+const OUT_757: usize = 8;
+fn aiur_fn_757(
+  inp: [G; IN_757],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_787], ExecError> {
+) -> Result<[G; OUT_757], 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 };
@@ -65582,12 +63041,12 @@ fn aiur_fn_787(
         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_787] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
-        record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_757] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
+        record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_47]; 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 __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_47]; 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_48: G = __r_arr[0];
         let __v_49: G = __r_arr[1];
         let __v_50: G = __r_arr[2];
@@ -65596,7 +63055,7 @@ fn aiur_fn_787(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -65605,8 +63064,8 @@ fn aiur_fn_787(
         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_787] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-        record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_757] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
+        record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65616,15 +63075,15 @@ fn aiur_fn_787(
   })
 }
 
-const INPUT_SIZE_788: usize = 8;
-const IN_788: usize = 8;
-const OUT_788: usize = 6;
-fn aiur_fn_788(
-  inp: [G; IN_788],
+const INPUT_SIZE_758: usize = 8;
+const IN_758: usize = 8;
+const OUT_758: usize = 6;
+fn aiur_fn_758(
+  inp: [G; IN_758],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_788], ExecError> {
+) -> Result<[G; OUT_758], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65634,7 +63093,7 @@ fn aiur_fn_788(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_803] = { let __args: [G; IN_803] = [__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[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_773] = { let __args: [G; IN_773] = [__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[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_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
@@ -65645,8 +63104,8 @@ fn aiur_fn_788(
       0u64 => {
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(1);
-        let __ret: [G; OUT_788] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
-        record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_758] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
+        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65656,15 +63115,15 @@ fn aiur_fn_788(
   })
 }
 
-const INPUT_SIZE_789: usize = 1;
-const IN_789: usize = 1;
-const OUT_789: usize = 8;
-fn aiur_fn_789(
-  inp: [G; IN_789],
+const INPUT_SIZE_759: usize = 1;
+const IN_759: usize = 1;
+const OUT_759: usize = 8;
+fn aiur_fn_759(
+  inp: [G; IN_759],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_789], ExecError> {
+) -> Result<[G; OUT_759], 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 };
@@ -65689,12 +63148,12 @@ fn aiur_fn_789(
         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_789] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_759] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_11]; 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_759] = { let __args: [G; IN_759] = [__v_11]; 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -65703,7 +63162,7 @@ fn aiur_fn_789(
         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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -65712,8 +63171,8 @@ fn aiur_fn_789(
         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_789] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
-        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_759] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
+        record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65723,15 +63182,15 @@ fn aiur_fn_789(
   })
 }
 
-const INPUT_SIZE_790: usize = 2;
-const IN_790: usize = 2;
-const OUT_790: usize = 1;
-fn aiur_fn_790(
-  inp: [G; IN_790],
+const INPUT_SIZE_760: usize = 2;
+const IN_760: usize = 2;
+const OUT_760: usize = 1;
+fn aiur_fn_760(
+  inp: [G; IN_760],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_790], ExecError> {
+) -> Result<[G; OUT_760], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65742,17 +63201,17 @@ fn aiur_fn_790(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_790] = [__v_1];
-        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_760] = [__v_1];
+        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_5, __v_1]; 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 __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5, __v_1]; 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_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_790] = [__v_8];
-        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_760] = [__v_8];
+        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65762,15 +63221,15 @@ fn aiur_fn_790(
   })
 }
 
-const INPUT_SIZE_791: usize = 9;
-const IN_791: usize = 9;
-const OUT_791: usize = 34;
-fn aiur_fn_791(
-  inp: [G; IN_791],
+const INPUT_SIZE_761: usize = 9;
+const IN_761: usize = 9;
+const OUT_761: usize = 34;
+fn aiur_fn_761(
+  inp: [G; IN_761],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_791], ExecError> {
+) -> Result<[G; OUT_761], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65824,12 +63283,12 @@ fn aiur_fn_791(
         let __v_45: G = __r_arr[0];
         match __v_45.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_791] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_761] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[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_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_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
             let __v_48: G = __r_arr[2];
@@ -65838,7 +63297,7 @@ fn aiur_fn_791(
             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_791] = { let __args: [G; IN_791] = [__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[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 __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__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[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 __v_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
             let __v_56: G = __r_arr[2];
@@ -65873,8 +63332,8 @@ fn aiur_fn_791(
             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_791] = [__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[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_761] = [__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[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65889,15 +63348,15 @@ fn aiur_fn_791(
   })
 }
 
-const INPUT_SIZE_792: usize = 1;
-const IN_792: usize = 1;
-const OUT_792: usize = 1;
-fn aiur_fn_792(
-  inp: [G; IN_792],
+const INPUT_SIZE_762: usize = 1;
+const IN_762: usize = 1;
+const OUT_762: usize = 1;
+fn aiur_fn_762(
+  inp: [G; IN_762],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_792], ExecError> {
+) -> Result<[G; OUT_762], 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 };
@@ -65907,14 +63366,14 @@ fn aiur_fn_792(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_792] = [__v_4];
-        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_762] = [__v_4];
+        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_792] = [__v_4];
-        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_762] = [__v_4];
+        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65924,19 +63383,19 @@ fn aiur_fn_792(
   })
 }
 
-const INPUT_SIZE_793: usize = 2;
-const IN_793: usize = 2;
-const OUT_793: usize = 3;
-fn aiur_fn_793(
-  inp: [G; IN_793],
+const INPUT_SIZE_763: usize = 2;
+const IN_763: usize = 2;
+const OUT_763: usize = 3;
+fn aiur_fn_763(
+  inp: [G; IN_763],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_793], ExecError> {
+) -> Result<[G; OUT_763], 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_804] = { let __args: [G; IN_804] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[804].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_804] = unsafe { *(result.output.as_ptr() as *const [G; OUT_804]) }; __ret } else { aiur_fn_804(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_1]; 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_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];
@@ -65946,8 +63405,8 @@ fn aiur_fn_793(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_793] = [__v_4, __v_5, __v_6];
-        record.function_queries[793].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_763] = [__v_4, __v_5, __v_6];
+        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65957,28 +63416,28 @@ fn aiur_fn_793(
   })
 }
 
-const INPUT_SIZE_794: usize = 2;
-const IN_794: usize = 2;
-const OUT_794: usize = 1;
-fn aiur_fn_794(
-  inp: [G; IN_794],
+const INPUT_SIZE_764: usize = 2;
+const IN_764: usize = 2;
+const OUT_764: usize = 1;
+fn aiur_fn_764(
+  inp: [G; IN_764],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_794], ExecError> {
+) -> Result<[G; OUT_764], 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_794] = [__v_0];
-        record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_764] = [__v_0];
+        record.function_queries[764].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_794] = { let __args: [G; IN_794] = [__v_0, __v_3]; 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 __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_3]; 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 __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];
@@ -65989,8 +63448,8 @@ fn aiur_fn_794(
         let __v_10: G = __loaded[5];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_794] = [__v_10];
-            record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_764] = [__v_10];
+            record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66002,15 +63461,15 @@ fn aiur_fn_794(
   })
 }
 
-const INPUT_SIZE_795: usize = 2;
-const IN_795: usize = 2;
-const OUT_795: usize = 1;
-fn aiur_fn_795(
-  inp: [G; IN_795],
+const INPUT_SIZE_765: usize = 2;
+const IN_765: usize = 2;
+const OUT_765: usize = 1;
+fn aiur_fn_765(
+  inp: [G; IN_765],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_795], ExecError> {
+) -> Result<[G; OUT_765], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66019,8 +63478,8 @@ fn aiur_fn_795(
         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_795] = [__v_4];
-        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_765] = [__v_4];
+        record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66033,11 +63492,11 @@ fn aiur_fn_795(
             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_795] = { let __args: [G; IN_795] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_4, __v_7]; 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 __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_795] = [__v_9];
-            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_765] = [__v_9];
+            record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66049,15 +63508,15 @@ fn aiur_fn_795(
   })
 }
 
-const INPUT_SIZE_796: usize = 1;
-const IN_796: usize = 1;
-const OUT_796: usize = 1;
-fn aiur_fn_796(
-  inp: [G; IN_796],
+const INPUT_SIZE_766: usize = 1;
+const IN_766: usize = 1;
+const OUT_766: usize = 1;
+fn aiur_fn_766(
+  inp: [G; IN_766],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_796], ExecError> {
+) -> Result<[G; OUT_766], 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 };
@@ -66100,17 +63559,17 @@ fn aiur_fn_796(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_796] = [__v_37];
-        record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_766] = [__v_37];
+        record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_36]; 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_766] = { let __args: [G; IN_766] = [__v_36]; 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 __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_796] = [__v_39];
-        record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_766] = [__v_39];
+        record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66120,15 +63579,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_767: usize = 1;
+const IN_767: usize = 1;
+const OUT_767: usize = 1;
+fn aiur_fn_767(
+  inp: [G; IN_767],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_797], ExecError> {
+) -> Result<[G; OUT_767], 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 };
@@ -66141,17 +63600,17 @@ fn aiur_fn_797(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_797] = [__v_7];
-        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_767] = [__v_7];
+        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_6]; 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 __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_797] = [__v_9];
-        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_767] = [__v_9];
+        record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66161,15 +63620,15 @@ fn aiur_fn_797(
   })
 }
 
-const INPUT_SIZE_798: usize = 2;
-const IN_798: usize = 2;
-const OUT_798: usize = 1;
-fn aiur_fn_798(
-  inp: [G; IN_798],
+const INPUT_SIZE_768: usize = 2;
+const IN_768: usize = 2;
+const OUT_768: usize = 1;
+fn aiur_fn_768(
+  inp: [G; IN_768],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_798], ExecError> {
+) -> Result<[G; OUT_768], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66178,8 +63637,8 @@ fn aiur_fn_798(
         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_798] = [__v_4];
-        record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_768] = [__v_4];
+        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66195,11 +63654,11 @@ fn aiur_fn_798(
             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_798] = { let __args: [G; IN_798] = [__v_7, __v_10]; 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_768] = { let __args: [G; IN_768] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } else { aiur_fn_768(__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_798] = [__v_12];
-            record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_768] = [__v_12];
+            record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66211,28 +63670,28 @@ 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_769: usize = 2;
+const IN_769: usize = 2;
+const OUT_769: usize = 1;
+fn aiur_fn_769(
+  inp: [G; IN_769],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_799], ExecError> {
+) -> Result<[G; OUT_769], 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_799] = [__v_0];
-        record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_769] = [__v_0];
+        record.function_queries[769].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_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 __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } else { aiur_fn_769(__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];
@@ -66240,8 +63699,8 @@ fn aiur_fn_799(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_799] = [__v_7];
-            record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_769] = [__v_7];
+            record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66253,15 +63712,15 @@ fn aiur_fn_799(
   })
 }
 
-const INPUT_SIZE_800: usize = 1;
-const IN_800: usize = 1;
-const OUT_800: usize = 1;
-fn aiur_fn_800(
-  inp: [G; IN_800],
+const INPUT_SIZE_770: usize = 1;
+const IN_770: usize = 1;
+const OUT_770: usize = 1;
+fn aiur_fn_770(
+  inp: [G; IN_770],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_800], ExecError> {
+) -> Result<[G; OUT_770], 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 };
@@ -66273,17 +63732,17 @@ fn aiur_fn_800(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_800] = [__v_6];
-        record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_770] = [__v_6];
+        record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_5]; 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_770] = { let __args: [G; IN_770] = [__v_5]; 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_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_800] = [__v_8];
-        record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_770] = [__v_8];
+        record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66293,15 +63752,15 @@ fn aiur_fn_800(
   })
 }
 
-const INPUT_SIZE_801: usize = 9;
-const IN_801: usize = 9;
-const OUT_801: usize = 1;
-fn aiur_fn_801(
-  inp: [G; IN_801],
+const INPUT_SIZE_771: usize = 9;
+const IN_771: usize = 9;
+const OUT_771: usize = 1;
+fn aiur_fn_771(
+  inp: [G; IN_771],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_801], ExecError> {
+) -> Result<[G; OUT_771], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66330,17 +63789,17 @@ fn aiur_fn_801(
         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_801] = [__v_23];
-        record.function_queries[801].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_771] = [__v_23];
+        record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_801] = { let __args: [G; IN_801] = [__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[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 __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__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[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 __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_801] = [__v_21];
-        record.function_queries[801].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_771] = [__v_21];
+        record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66350,15 +63809,15 @@ fn aiur_fn_801(
   })
 }
 
-const INPUT_SIZE_802: usize = 2;
-const IN_802: usize = 2;
-const OUT_802: usize = 1;
-fn aiur_fn_802(
-  inp: [G; IN_802],
+const INPUT_SIZE_772: usize = 2;
+const IN_772: usize = 2;
+const OUT_772: usize = 1;
+fn aiur_fn_772(
+  inp: [G; IN_772],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_802], ExecError> {
+) -> Result<[G; OUT_772], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66368,17 +63827,17 @@ fn aiur_fn_802(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_802] = [__v_1];
-        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_772] = [__v_1];
+        record.function_queries[772].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_802] = { let __args: [G; IN_802] = [__v_4, __v_6]; 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_772] = { let __args: [G; IN_772] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_802] = [__v_7];
-        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_772] = [__v_7];
+        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66388,15 +63847,15 @@ fn aiur_fn_802(
   })
 }
 
-const INPUT_SIZE_803: usize = 8;
-const IN_803: usize = 8;
-const OUT_803: usize = 6;
-fn aiur_fn_803(
-  inp: [G; IN_803],
+const INPUT_SIZE_773: usize = 8;
+const IN_773: usize = 8;
+const OUT_773: usize = 6;
+fn aiur_fn_773(
+  inp: [G; IN_773],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_803], ExecError> {
+) -> 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];
@@ -66416,8 +63875,8 @@ fn aiur_fn_803(
         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_803] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
-        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_773] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
+        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -66438,22 +63897,22 @@ fn aiur_fn_803(
         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_803] = { let __args: [G; IN_803] = [__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[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_773] = { let __args: [G; IN_773] = [__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[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 = __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_805] = { let __args: [G; IN_805] = [__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[805].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_805] = unsafe { *(result.output.as_ptr() as *const [G; OUT_805]) }; __ret } else { aiur_fn_805(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__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[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 __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_803] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_773] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
+            record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66463,27 +63922,27 @@ fn aiur_fn_803(
                 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_803] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
-                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_773] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
+                record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_803] = { let __args: [G; IN_803] = [__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[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_773] = { let __args: [G; IN_773] = [__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[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_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_805] = { let __args: [G; IN_805] = [__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[805].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_805] = unsafe { *(result.output.as_ptr() as *const [G; OUT_805]) }; __ret } else { aiur_fn_805(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__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[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_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_803] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_773] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+                record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -66497,28 +63956,28 @@ fn aiur_fn_803(
   })
 }
 
-const INPUT_SIZE_804: usize = 2;
-const IN_804: usize = 2;
-const OUT_804: usize = 1;
-fn aiur_fn_804(
-  inp: [G; IN_804],
+const INPUT_SIZE_774: usize = 2;
+const IN_774: usize = 2;
+const OUT_774: usize = 1;
+fn aiur_fn_774(
+  inp: [G; IN_774],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_804], ExecError> {
+) -> Result<[G; OUT_774], 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_804] = [__v_0];
-        record.function_queries[804].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_774] = [__v_0];
+        record.function_queries[774].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_804] = { let __args: [G; IN_804] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[804].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_804] = unsafe { *(result.output.as_ptr() as *const [G; OUT_804]) }; __ret } else { aiur_fn_804(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_3]; 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_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];
@@ -66528,8 +63987,8 @@ fn aiur_fn_804(
         let __v_9: G = __loaded[4];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_804] = [__v_9];
-            record.function_queries[804].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_774] = [__v_9];
+            record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66541,15 +64000,15 @@ fn aiur_fn_804(
   })
 }
 
-const INPUT_SIZE_805: usize = 15;
-const IN_805: usize = 15;
-const OUT_805: usize = 6;
-fn aiur_fn_805(
-  inp: [G; IN_805],
+const INPUT_SIZE_775: usize = 15;
+const IN_775: usize = 15;
+const OUT_775: usize = 6;
+fn aiur_fn_775(
+  inp: [G; IN_775],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_805], ExecError> {
+) -> Result<[G; OUT_775], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66568,38 +64027,38 @@ fn aiur_fn_805(
     let __v_14: G = inp[14];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_806] = { let __args: [G; IN_806] = [__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[806].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_806] = unsafe { *(result.output.as_ptr() as *const [G; OUT_806]) }; __ret } else { aiur_fn_806(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__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[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 __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_805] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
-        record.function_queries[805].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_775] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
+        record.function_queries[775].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_805] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
-        record.function_queries[805].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_775] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
+        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_806: usize = 14;
-const IN_806: usize = 14;
-const OUT_806: usize = 6;
-fn aiur_fn_806(
-  inp: [G; IN_806],
+const INPUT_SIZE_776: usize = 14;
+const IN_776: usize = 14;
+const OUT_776: usize = 6;
+fn aiur_fn_776(
+  inp: [G; IN_776],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_806], ExecError> {
+) -> Result<[G; OUT_776], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66639,8 +64098,8 @@ fn aiur_fn_806(
                     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_806] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
-                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_776] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
+                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -66664,8 +64123,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -66693,8 +64152,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66718,8 +64177,8 @@ fn aiur_fn_806(
                                                     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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -66727,8 +64186,8 @@ fn aiur_fn_806(
                                                     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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -66738,8 +64197,8 @@ fn aiur_fn_806(
                                                 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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66767,8 +64226,8 @@ fn aiur_fn_806(
                                                 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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66776,8 +64235,8 @@ fn aiur_fn_806(
                                                 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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66787,8 +64246,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66800,8 +64259,8 @@ fn aiur_fn_806(
                                     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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -66811,8 +64270,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66844,8 +64303,8 @@ fn aiur_fn_806(
                                         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_806] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_776] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66869,8 +64328,8 @@ fn aiur_fn_806(
                                                 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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66878,8 +64337,8 @@ fn aiur_fn_806(
                                                 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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66889,8 +64348,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66918,8 +64377,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66927,8 +64386,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66938,8 +64397,8 @@ fn aiur_fn_806(
                                         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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -66951,8 +64410,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66962,8 +64421,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -66993,8 +64452,8 @@ fn aiur_fn_806(
                         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_806] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_776] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -67022,8 +64481,8 @@ fn aiur_fn_806(
                                         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_806] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_776] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -67047,8 +64506,8 @@ fn aiur_fn_806(
                                                 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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -67056,8 +64515,8 @@ fn aiur_fn_806(
                                                 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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -67067,8 +64526,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -67096,8 +64555,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -67105,8 +64564,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -67116,8 +64575,8 @@ fn aiur_fn_806(
                                         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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67129,8 +64588,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67140,8 +64599,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67173,8 +64632,8 @@ fn aiur_fn_806(
                                     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_806] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_776] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67198,8 +64657,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -67207,8 +64666,8 @@ fn aiur_fn_806(
                                             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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -67218,8 +64677,8 @@ fn aiur_fn_806(
                                         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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67247,8 +64706,8 @@ fn aiur_fn_806(
                                         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_806] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_776] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -67256,8 +64715,8 @@ fn aiur_fn_806(
                                         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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67267,8 +64726,8 @@ fn aiur_fn_806(
                                     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_806] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_776] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67280,8 +64739,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67291,8 +64750,8 @@ fn aiur_fn_806(
                         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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -67326,8 +64785,8 @@ fn aiur_fn_806(
                             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_806] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67351,8 +64810,8 @@ fn aiur_fn_806(
                                     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_806] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_776] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67360,8 +64819,8 @@ fn aiur_fn_806(
                                     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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67371,8 +64830,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67400,8 +64859,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67409,8 +64868,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67420,8 +64879,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67433,8 +64892,8 @@ fn aiur_fn_806(
                     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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                    record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_776] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                    record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -67444,8 +64903,8 @@ fn aiur_fn_806(
                 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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_776] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -67477,8 +64936,8 @@ fn aiur_fn_806(
                         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_806] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_776] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -67502,8 +64961,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67511,8 +64970,8 @@ fn aiur_fn_806(
                                 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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67522,8 +64981,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67551,8 +65010,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67560,8 +65019,8 @@ fn aiur_fn_806(
                             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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67571,8 +65030,8 @@ fn aiur_fn_806(
                         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_806] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_776] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -67584,8 +65043,8 @@ fn aiur_fn_806(
                 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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_776] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -67595,8 +65054,8 @@ fn aiur_fn_806(
             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_806] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-            record.function_queries[806].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_776] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+            record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -71497,156 +68956,6 @@ pub(crate) fn execute_generated(
       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());
-    },
-    804u64 => {
-      let __inp: [G; IN_804] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_804(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    805u64 => {
-      let __inp: [G; IN_805] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_805(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    806u64 => {
-      let __inp: [G; IN_806] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_806(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
     _ => {
       return Err(ExecError::InvalidFunIdx(fun_idx));
     },
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs
new file mode 100644
index 000000000..8d66fb040
--- /dev/null
+++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs
@@ -0,0 +1,19006 @@
+// Auto-generated by Aiur codegen. Do not edit.
+//
+// Mirrors `crates/aiur/src/execute.rs`'s QueryRecord side effects exactly.
+//
+// Skip rustfmt — this file is huge and the codegen lays it out
+// for the compiler, not for humans.
+#![cfg_attr(rustfmt, rustfmt::skip)]
+#![allow(
+  unused_variables, unused_assignments, unused_mut, dead_code,
+  unused_parens, non_snake_case, clippy::all,
+  clippy::ptr_as_ptr, clippy::match_same_arms,
+  clippy::large_types_passed_by_value,
+)]
+
+use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
+use aiur::G;
+use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_add_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 };
+
+const INPUT_SIZE_0: usize = 3;
+const IN_0: usize = 3;
+const OUT_0: usize = 1;
+fn aiur_fn_0(
+  inp: [G; IN_0],
+  record: &mut QueryRecord,
+  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 __v_2: G = inp[2];
+    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_0] = [__v_5];
+        record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_3: G = G::from_u64(1);
+        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 __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));
+        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],
+  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 __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_1.as_canonical_u64() {
+          0u64 => {
+            match __v_2.as_canonical_u64() {
+              0u64 => {
+                match __v_3.as_canonical_u64() {
+                  0u64 => {
+                    match __v_4.as_canonical_u64() {
+                      0u64 => {
+                        match __v_5.as_canonical_u64() {
+                          0u64 => {
+                            match __v_6.as_canonical_u64() {
+                              0u64 => {
+                                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));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_8: G = G::from_u64(0);
+                                    let __ret: [G; OUT_1] = [__v_8];
+                                    record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __v_8: G = G::from_u64(0);
+                                let __ret: [G; OUT_1] = [__v_8];
+                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_8: G = G::from_u64(0);
+                            let __ret: [G; OUT_1] = [__v_8];
+                            record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_8: G = G::from_u64(0);
+                        let __ret: [G; OUT_1] = [__v_8];
+                        record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_8: G = G::from_u64(0);
+                    let __ret: [G; OUT_1] = [__v_8];
+                    record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_8: G = G::from_u64(0);
+                let __ret: [G; OUT_1] = [__v_8];
+                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_1] = [__v_8];
+            record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_1] = [__v_8];
+        record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_2: usize = 8;
+const IN_2: usize = 8;
+const OUT_2: usize = 4;
+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];
+    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 __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) };
+    let __v_8: G = __b2_add.0;
+    let __v_9: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) };
+    let __v_10: G = __b2_add.0;
+    let __v_11: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_9) } else { bytes2_add_value(__v_10, __v_9, record) };
+    let __v_12: G = __b2_add.0;
+    let __v_13: G = __b2_add.1;
+    let __v_14: G = (__v_11 + __v_13);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) };
+    let __v_15: G = __b2_add.0;
+    let __v_16: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_15, &__v_14) } else { bytes2_add_value(__v_15, __v_14, record) };
+    let __v_17: G = __b2_add.0;
+    let __v_18: G = __b2_add.1;
+    let __v_19: G = (__v_16 + __v_18);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) };
+    let __v_20: G = __b2_add.0;
+    let __v_21: G = __b2_add.1;
+    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_2] = [__v_8, __v_12, __v_17, __v_22];
+    record.function_queries[2].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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    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 = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) };
+    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_3] = [__v_8, __v_9, __v_10, __v_11];
+    record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_4: usize = 4;
+const IN_4: usize = 4;
+const OUT_4: usize = 4;
+fn aiur_fn_4(
+  inp: [G; IN_4],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_4] = [__v_2, __v_3, __v_0, __v_1];
+    record.function_queries[4].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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_5] = [__v_1, __v_2, __v_3, __v_0];
+    record.function_queries[5].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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_1, &__v_2) } else { bytes2_chain_rotr4_value(__v_1, __v_2, record) };
+    let __v_4: G = __b2_out.0;
+    let __v_5: G = __b2_out.1;
+    let __v_6: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_3, &__v_0) } else { bytes2_chain_rotr4_value(__v_3, __v_0, record) };
+    let __v_7: G = __b2_out.0;
+    let __v_8: G = __b2_out.1;
+    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_6] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[6].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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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 __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_0, &__v_1) } else { bytes2_chain_rotr7_value(__v_0, __v_1, record) };
+    let __v_4: G = __b2_out.0;
+    let __v_5: G = __b2_out.1;
+    let __v_6: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_2, &__v_3) } else { bytes2_chain_rotr7_value(__v_2, __v_3, record) };
+    let __v_7: G = __b2_out.0;
+    let __v_8: G = __b2_out.1;
+    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));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_8: usize = 8;
+const IN_8: usize = 8;
+const OUT_8: usize = 8;
+fn aiur_fn_8(
+  inp: [G; IN_8],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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 __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() {
+      255u64 => {
+        match __v_1.as_canonical_u64() {
+          255u64 => {
+            match __v_2.as_canonical_u64() {
+              255u64 => {
+                match __v_3.as_canonical_u64() {
+                  255u64 => {
+                    match __v_4.as_canonical_u64() {
+                      255u64 => {
+                        match __v_5.as_canonical_u64() {
+                          255u64 => {
+                            match __v_6.as_canonical_u64() {
+                              255u64 => {
+                                match __v_7.as_canonical_u64() {
+                                  255u64 => {
+                                    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 __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    record.function_queries[8].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 = 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(1);
+                                    let __v_16: G = (__v_7 + __v_15);
+                                    let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    record.function_queries[8].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 = G::from_u64(0);
+                                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_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                record.function_queries[8].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 = G::from_u64(0);
+                            let __v_13: G = G::from_u64(1);
+                            let __v_14: G = (__v_5 + __v_13);
+                            let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            record.function_queries[8].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 = G::from_u64(1);
+                        let __v_13: G = (__v_4 + __v_12);
+                        let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        record.function_queries[8].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(1);
+                    let __v_12: G = (__v_3 + __v_11);
+                    let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    record.function_queries[8].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(1);
+                let __v_11: G = (__v_2 + __v_10);
+                let __ret: [G; OUT_8] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                record.function_queries[8].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 = (__v_1 + __v_9);
+            let __ret: [G; OUT_8] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_0 + __v_8);
+        let __ret: [G; OUT_8] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_9: usize = 8;
+const IN_9: usize = 8;
+const OUT_9: usize = 1;
+fn aiur_fn_9(
+  inp: [G; IN_9],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    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);
+    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(256);
+    let __v_10: G = (__v_9 * __v_1);
+    let __v_11: G = G::from_u64(65536);
+    let __v_12: G = (__v_11 * __v_2);
+    let __v_13: G = G::from_u64(16777216);
+    let __v_14: G = (__v_13 * __v_3);
+    let __v_15: G = G::from_u64(4294967296);
+    let __v_16: G = (__v_15 * __v_4);
+    let __v_17: G = G::from_u64(1099511627776);
+    let __v_18: G = (__v_17 * __v_5);
+    let __v_19: G = G::from_u64(281474976710656);
+    let __v_20: G = (__v_19 * __v_6);
+    let __v_21: G = (__v_18 + __v_20);
+    let __v_22: G = (__v_16 + __v_21);
+    let __v_23: G = (__v_14 + __v_22);
+    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_9] = [__v_26];
+    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_10: usize = 8;
+const IN_10: usize = 8;
+const OUT_10: usize = 1;
+fn aiur_fn_10(
+  inp: [G; IN_10],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    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(256);
+    let __v_9: G = (__v_8 * __v_1);
+    let __v_10: G = G::from_u64(65536);
+    let __v_11: G = (__v_10 * __v_2);
+    let __v_12: G = G::from_u64(16777216);
+    let __v_13: G = (__v_12 * __v_3);
+    let __v_14: G = G::from_u64(4294967296);
+    let __v_15: G = (__v_14 * __v_4);
+    let __v_16: G = G::from_u64(1099511627776);
+    let __v_17: G = (__v_16 * __v_5);
+    let __v_18: G = G::from_u64(281474976710656);
+    let __v_19: G = (__v_18 * __v_6);
+    let __v_20: G = G::from_u64(72057594037927936);
+    let __v_21: G = (__v_20 * __v_7);
+    let __v_22: G = (__v_19 + __v_21);
+    let __v_23: G = (__v_17 + __v_22);
+    let __v_24: G = (__v_15 + __v_23);
+    let __v_25: G = (__v_13 + __v_24);
+    let __v_26: G = (__v_11 + __v_25);
+    let __v_27: G = (__v_9 + __v_26);
+    let __v_28: G = (__v_0 + __v_27);
+    let __ret: [G; OUT_10] = [__v_28];
+    record.function_queries[10].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 = 1;
+fn aiur_fn_11(
+  inp: [G; IN_11],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    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(1020);
+    let __v_9: G = (__v_7 - __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = (__v_5 + __v_10);
+    let __v_12: G = (__v_4 + __v_11);
+    let __v_13: G = G::from_bool((__v_12 == G::ZERO));
+    let __v_14: G = (__v_2 + __v_3);
+    let __v_15: G = (__v_1 + __v_14);
+    let __v_16: G = (__v_0 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = (__v_19 - __v_17);
+    let __v_21: G = (__v_13 * __v_20);
+    let __v_22: G = (__v_18 - __v_21);
+    let __ret: [G; OUT_11] = [__v_22];
+    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_12: usize = 1;
+const IN_12: usize = 1;
+const OUT_12: usize = 8;
+fn aiur_fn_12(
+  inp: [G; IN_12],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_12], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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_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() });
+    }
+    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() });
+    }
+    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));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_13: usize = 2;
+const IN_13: usize = 2;
+const OUT_13: usize = 1;
+fn aiur_fn_13(
+  inp: [G; IN_13],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_13], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = (__v_0 + __v_1);
+    let __ret: [G; OUT_13] = [__v_2];
+    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_14: usize = 2;
+const IN_14: usize = 2;
+const OUT_14: usize = 1;
+fn aiur_fn_14(
+  inp: [G; IN_14],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_14], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = (__v_0 * __v_1);
+    let __ret: [G; OUT_14] = [__v_2];
+    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_15: usize = 1;
+const IN_15: usize = 1;
+const OUT_15: usize = 1;
+fn aiur_fn_15(
+  inp: [G; IN_15],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_15], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = (__v_0 * __v_0);
+    let __ret: [G; OUT_15] = [__v_1];
+    record.function_queries[15].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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_16], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = g_inverse_value(__v_0);
+    let __v_2: G = (__v_0 * __v_1);
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_2 - __v_3);
+    let __v_5: G = (__v_0 * __v_4);
+    let __v_6: G = G::from_u64(0);
+    if (__v_5 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
+    }
+    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() });
+    }
+    let __ret: [G; OUT_16] = [__v_1];
+    record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_17: usize = 4;
+const IN_17: usize = 4;
+const OUT_17: usize = 2;
+fn aiur_fn_17(
+  inp: [G; IN_17],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_17], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 + __v_2);
+    let __v_5: G = (__v_1 + __v_3);
+    let __ret: [G; OUT_17] = [__v_4, __v_5];
+    record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_18: usize = 4;
+const IN_18: usize = 4;
+const OUT_18: usize = 2;
+fn aiur_fn_18(
+  inp: [G; IN_18],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_18], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 - __v_2);
+    let __v_5: G = (__v_1 - __v_3);
+    let __ret: [G; OUT_18] = [__v_4, __v_5];
+    record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_19: usize = 2;
+const IN_19: usize = 2;
+const OUT_19: usize = 2;
+fn aiur_fn_19(
+  inp: [G; IN_19],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_19], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = (__v_2 - __v_0);
+    let __v_4: G = G::from_u64(0);
+    let __v_5: G = (__v_4 - __v_1);
+    let __ret: [G; OUT_19] = [__v_3, __v_5];
+    record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_20: usize = 4;
+const IN_20: usize = 4;
+const OUT_20: usize = 2;
+fn aiur_fn_20(
+  inp: [G; IN_20],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_20], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 * __v_2);
+    let __v_5: G = G::from_u64(7);
+    let __v_6: G = (__v_1 * __v_3);
+    let __v_7: G = (__v_5 * __v_6);
+    let __v_8: G = (__v_4 + __v_7);
+    let __v_9: G = (__v_0 * __v_3);
+    let __v_10: G = (__v_1 * __v_2);
+    let __v_11: G = (__v_9 + __v_10);
+    let __ret: [G; OUT_20] = [__v_8, __v_11];
+    record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_21: usize = 2;
+const IN_21: usize = 2;
+const OUT_21: usize = 2;
+fn aiur_fn_21(
+  inp: [G; IN_21],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_21], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = (__v_0 * __v_0);
+    let __v_3: G = G::from_u64(7);
+    let __v_4: G = (__v_1 * __v_1);
+    let __v_5: G = (__v_3 * __v_4);
+    let __v_6: G = (__v_2 - __v_5);
+    let __v_7: G = g_inverse_value(__v_6);
+    let __v_8: G = (__v_6 * __v_7);
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = (__v_8 - __v_9);
+    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() });
+    }
+    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() });
+    }
+    let __v_15: G = (__v_0 * __v_7);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = (__v_16 - __v_1);
+    let __v_18: G = (__v_17 * __v_7);
+    let __ret: [G; OUT_21] = [__v_15, __v_18];
+    record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_22: usize = 4;
+const IN_22: usize = 4;
+const OUT_22: usize = 2;
+fn aiur_fn_22(
+  inp: [G; IN_22],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_22], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_2, __v_3]; 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_4, __v_5]; 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_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __ret: [G; OUT_22] = [__v_6, __v_7];
+    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_23: usize = 4;
+const IN_23: usize = 4;
+const OUT_23: usize = 1;
+fn aiur_fn_23(
+  inp: [G; IN_23],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_23], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 - __v_2);
+    let __v_5: G = G::from_bool((__v_4 == G::ZERO));
+    let __v_6: G = (__v_1 - __v_3);
+    let __v_7: G = G::from_bool((__v_6 == G::ZERO));
+    let __v_8: G = (__v_5 * __v_7);
+    let __ret: [G; OUT_23] = [__v_8];
+    record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_24: usize = 1;
+const IN_24: usize = 1;
+const OUT_24: usize = 2;
+fn aiur_fn_24(
+  inp: [G; IN_24],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_24], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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_24] = [__v_2, __v_3];
+        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_24] = [__v_4, __v_7];
+        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_25: usize = 1;
+const IN_25: usize = 1;
+const OUT_25: usize = 9;
+fn aiur_fn_25(
+  inp: [G; IN_25],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_25], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_4]; 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__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_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_8]; 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12]; 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_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_14]; 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_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __ret: [G; OUT_25] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 2;
+fn aiur_fn_26(
+  inp: [G; IN_26],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_26], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = 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_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_9] = { let __args: [G; IN_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[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_10: G = __r_arr[0];
+    let __ret: [G; OUT_26] = [__v_10, __v_9];
+    record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_27: usize = 1;
+const IN_27: usize = 1;
+const OUT_27: usize = 2;
+fn aiur_fn_27(
+  inp: [G; IN_27],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_27], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_0 + __v_3);
+    let __ret: [G; OUT_27] = [__v_2, __v_4];
+    record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_28: usize = 1;
+const IN_28: usize = 1;
+const OUT_28: usize = 9;
+fn aiur_fn_28(
+  inp: [G; IN_28],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_28], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = __io_read[2];
+    let __v_5: G = __io_read[3];
+    let __v_6: G = __io_read[4];
+    let __v_7: G = __io_read[5];
+    let __v_8: G = __io_read[6];
+    let __v_9: G = __io_read[7];
+    let __v_10: G = G::from_u64(8);
+    let __v_11: G = (__v_0 + __v_10);
+    let __ret: [G; OUT_28] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
+    record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_29: usize = 1;
+const IN_29: usize = 1;
+const OUT_29: usize = 2;
+fn aiur_fn_29(
+  inp: [G; IN_29],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_29], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_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_9] = { let __args: [G; IN_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[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_10: G = __r_arr[0];
+    let __ret: [G; OUT_29] = [__v_10, __v_9];
+    record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_30: usize = 1;
+const IN_30: usize = 1;
+const OUT_30: usize = 3;
+fn aiur_fn_30(
+  inp: [G; IN_30],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_30], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __r_arr: [G; OUT_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_19: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_20: G = __r_arr[0];
+    let __ret: [G; OUT_30] = [__v_19, __v_20, __v_18];
+    record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_31: usize = 1;
+const IN_31: usize = 1;
+const OUT_31: usize = 33;
+fn aiur_fn_31(
+  inp: [G; IN_31],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_31], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __v_21: G = __r_arr[2];
+    let __v_22: G = __r_arr[3];
+    let __v_23: G = __r_arr[4];
+    let __v_24: G = __r_arr[5];
+    let __v_25: G = __r_arr[6];
+    let __v_26: G = __r_arr[7];
+    let __v_27: G = __r_arr[8];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __v_30: G = __r_arr[2];
+    let __v_31: G = __r_arr[3];
+    let __v_32: G = __r_arr[4];
+    let __v_33: G = __r_arr[5];
+    let __v_34: G = __r_arr[6];
+    let __v_35: G = __r_arr[7];
+    let __v_36: G = __r_arr[8];
+    let __ret: [G; OUT_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_32: usize = 1;
+const IN_32: usize = 1;
+const OUT_32: usize = 2;
+fn aiur_fn_32(
+  inp: [G; IN_32],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_32], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_32] = [__v_3, __v_4];
+    record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_33: usize = 2;
+const IN_33: usize = 2;
+const OUT_33: usize = 2;
+fn aiur_fn_33(
+  inp: [G; IN_33],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_33], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 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_33] = [__v_4, __v_0];
+        record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_33] = [__v_9, __v_7];
+        record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_34: usize = 1;
+const IN_34: usize = 1;
+const OUT_34: usize = 2;
+fn aiur_fn_34(
+  inp: [G; IN_34],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_34], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_34] = [__v_3, __v_4];
+    record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_35: usize = 2;
+const IN_35: usize = 2;
+const OUT_35: usize = 2;
+fn aiur_fn_35(
+  inp: [G; IN_35],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_35], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_35] = [__v_4, __v_0];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_12]; 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_35] = [__v_16, __v_14];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_36: usize = 1;
+const IN_36: usize = 1;
+const OUT_36: usize = 2;
+fn aiur_fn_36(
+  inp: [G; IN_36],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_36], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_36] = [__v_3, __v_4];
+    record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_37: usize = 2;
+const IN_37: usize = 2;
+const OUT_37: usize = 2;
+fn aiur_fn_37(
+  inp: [G; IN_37],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_37], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_37] = [__v_4, __v_0];
+        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_4, __v_6]; 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_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; 4] = [__v_9, __v_2, __v_3, __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_37] = [__v_10, __v_8];
+        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_38: usize = 1;
+const IN_38: usize = 1;
+const OUT_38: usize = 2;
+fn aiur_fn_38(
+  inp: [G; IN_38],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_38], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_38] = [__v_3, __v_4];
+    record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_39: usize = 2;
+const IN_39: usize = 2;
+const OUT_39: usize = 2;
+fn aiur_fn_39(
+  inp: [G; IN_39],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_39], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&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_39] = [__v_4, __v_0];
+        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0]; 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_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 = G::from_u64(1);
+        let __v_36: G = (__v_1 - __v_35);
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_34, __v_36]; 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_37: G = __r_arr[0];
+        let __v_38: G = __r_arr[1];
+        let __v_39: G = G::from_u64(0);
+        let __v_40: G = { let __values: [G; 34] = [__v_39, __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_37]; 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_39] = [__v_40, __v_38];
+        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_40: usize = 1;
+const IN_40: usize = 1;
+const OUT_40: usize = 2;
+fn aiur_fn_40(
+  inp: [G; IN_40],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_40], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_40] = [__v_3, __v_4];
+    record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_41: usize = 2;
+const IN_41: usize = 2;
+const OUT_41: usize = 2;
+fn aiur_fn_41(
+  inp: [G; IN_41],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_41] = [__v_4, __v_0];
+        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_41] = [__v_9, __v_7];
+        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_42: usize = 1;
+const IN_42: usize = 1;
+const OUT_42: usize = 2;
+fn aiur_fn_42(
+  inp: [G; IN_42],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_42], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_42] = [__v_3, __v_4];
+    record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_43: usize = 2;
+const IN_43: usize = 2;
+const OUT_43: usize = 2;
+fn aiur_fn_43(
+  inp: [G; IN_43],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    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_43] = [__v_4, __v_0];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_43] = [__v_9, __v_7];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_44: usize = 1;
+const IN_44: usize = 1;
+const OUT_44: usize = 2;
+fn aiur_fn_44(
+  inp: [G; IN_44],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_44], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_44] = [__v_3, __v_4];
+    record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_45: usize = 2;
+const IN_45: usize = 2;
+const OUT_45: usize = 2;
+fn aiur_fn_45(
+  inp: [G; IN_45],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_45], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      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_45] = [__v_4, __v_0];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0]; 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_45] = [__v_9, __v_7];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_46: usize = 1;
+const IN_46: usize = 1;
+const OUT_46: usize = 2;
+fn aiur_fn_46(
+  inp: [G; IN_46],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_46], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __ret: [G; OUT_46] = [__v_1, __v_2];
+    record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_47: usize = 1;
+const IN_47: usize = 1;
+const OUT_47: usize = 2;
+fn aiur_fn_47(
+  inp: [G; IN_47],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_47], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2, __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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_47] = [__v_3, __v_4];
+    record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_48: usize = 2;
+const IN_48: usize = 2;
+const OUT_48: usize = 2;
+fn aiur_fn_48(
+  inp: [G; IN_48],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_48], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      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_48] = [__v_4, __v_0];
+        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0]; 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_48] = [__v_9, __v_7];
+        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_49: usize = 1;
+const IN_49: usize = 1;
+const OUT_49: usize = 4;
+fn aiur_fn_49(
+  inp: [G; IN_49],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_49], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_49] = [__v_1, __v_3, __v_5, __v_6];
+    record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_50: usize = 1;
+const IN_50: usize = 1;
+const OUT_50: usize = 3;
+fn aiur_fn_50(
+  inp: [G; IN_50],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_50], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_50] = [__v_1, __v_3, __v_4];
+    record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_51: usize = 1;
+const IN_51: usize = 1;
+const OUT_51: usize = 2;
+fn aiur_fn_51(
+  inp: [G; IN_51],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_51], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_51] = [__v_3, __v_4];
+    record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_52: usize = 2;
+const IN_52: usize = 2;
+const OUT_52: usize = 2;
+fn aiur_fn_52(
+  inp: [G; IN_52],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_52], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_52] = [__v_4, __v_0];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_6]; 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_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; 4] = [__v_9, __v_2, __v_3, __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_52] = [__v_10, __v_8];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_53: usize = 1;
+const IN_53: usize = 1;
+const OUT_53: usize = 4;
+fn aiur_fn_53(
+  inp: [G; IN_53],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_53], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6];
+    record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_54: usize = 1;
+const IN_54: usize = 1;
+const OUT_54: usize = 2;
+fn aiur_fn_54(
+  inp: [G; IN_54],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_54], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_2, __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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_54] = [__v_3, __v_4];
+    record.function_queries[54].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 = 2;
+fn aiur_fn_55(
+  inp: [G; IN_55],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_55], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_55] = [__v_4, __v_0];
+        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0]; let __cu = 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_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(1);
+        let __v_7: G = (__v_1 - __v_6);
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_5, __v_7]; 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_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; 5] = [__v_10, __v_2, __v_3, __v_4, __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_55] = [__v_11, __v_9];
+        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_56: usize = 1;
+const IN_56: usize = 1;
+const OUT_56: usize = 3;
+fn aiur_fn_56(
+  inp: [G; IN_56],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_56], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_56] = [__v_1, __v_3, __v_4];
+    record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_57: usize = 1;
+const IN_57: usize = 1;
+const OUT_57: usize = 2;
+fn aiur_fn_57(
+  inp: [G; IN_57],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_57], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_57] = [__v_3, __v_4];
+    record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_58: usize = 2;
+const IN_58: usize = 2;
+const OUT_58: usize = 2;
+fn aiur_fn_58(
+  inp: [G; IN_58],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_4, __v_0];
+        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_0]; 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_4, __v_6]; 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_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; 4] = [__v_9, __v_2, __v_3, __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_58] = [__v_10, __v_8];
+        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_59: usize = 1;
+const IN_59: usize = 1;
+const OUT_59: usize = 13;
+fn aiur_fn_59(
+  inp: [G; IN_59],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_59], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0]; 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_4]; 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_8]; let __cu = true; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __v_11: G = __r_arr[2];
+    let __v_12: G = __r_arr[3];
+    let __v_13: G = __r_arr[4];
+    let __v_14: G = __r_arr[5];
+    let __v_15: G = __r_arr[6];
+    let __v_16: G = __r_arr[7];
+    let __v_17: G = __r_arr[8];
+    let __ret: [G; OUT_59] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17];
+    record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_60: usize = 1;
+const IN_60: usize = 1;
+const OUT_60: usize = 3;
+fn aiur_fn_60(
+  inp: [G; IN_60],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_60], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_60] = [__v_3, __v_4, __v_2];
+        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2]; 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_60] = [__v_5, __v_3, __v_4];
+        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_61: usize = 1;
+const IN_61: usize = 1;
+const OUT_61: usize = 24;
+fn aiur_fn_61(
+  inp: [G; IN_61],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_61], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_2]; 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_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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_8]; 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __v_21: G = __r_arr[10];
+    let __v_22: G = __r_arr[11];
+    let __v_23: G = __r_arr[12];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_23]; 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_24: G = __r_arr[0];
+    let __v_25: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_25]; 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_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __v_28: G = __r_arr[2];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_28]; 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_29: G = __r_arr[0];
+    let __v_30: G = __r_arr[1];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_30]; 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __ret: [G; OUT_61] = [__v_1, __v_3, __v_4, __v_5, __v_7, __v_9, __v_11, __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_26, __v_27, __v_29, __v_31, __v_32];
+    record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_62: usize = 1;
+const IN_62: usize = 1;
+const OUT_62: usize = 32;
+fn aiur_fn_62(
+  inp: [G; IN_62],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_62], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __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];
+    let __v_53: G = __loaded[1];
+    let __v_54: G = __loaded[2];
+    let __v_55: G = __loaded[3];
+    let __v_56: G = __loaded[4];
+    let __v_57: G = __loaded[5];
+    let __v_58: G = __loaded[6];
+    let __v_59: G = __loaded[7];
+    let __v_60: G = __loaded[8];
+    let __v_61: G = __loaded[9];
+    let __v_62: G = __loaded[10];
+    let __v_63: G = __loaded[11];
+    let __v_64: G = __loaded[12];
+    let __v_65: G = __loaded[13];
+    let __v_66: G = __loaded[14];
+    let __v_67: G = __loaded[15];
+    let __v_68: G = __loaded[16];
+    let __v_69: G = __loaded[17];
+    let __v_70: G = __loaded[18];
+    let __v_71: G = __loaded[19];
+    let __v_72: G = __loaded[20];
+    let __v_73: G = __loaded[21];
+    let __v_74: G = __loaded[22];
+    let __v_75: G = __loaded[23];
+    let __v_76: G = __loaded[24];
+    let __v_77: G = __loaded[25];
+    let __v_78: G = __loaded[26];
+    let __v_79: G = __loaded[27];
+    let __v_80: G = __loaded[28];
+    let __v_81: G = __loaded[29];
+    let __v_82: G = __loaded[30];
+    let __v_83: G = __loaded[31];
+    let __v_84: G = __loaded[32];
+    let __v_85: G = __loaded[33];
+    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__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[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_86: G = __r_arr[0];
+    let __v_87: G = __r_arr[1];
+    let __v_88: G = __r_arr[2];
+    let __v_89: G = __r_arr[3];
+    let __v_90: G = __r_arr[4];
+    let __v_91: G = __r_arr[5];
+    let __v_92: G = __r_arr[6];
+    let __v_93: G = __r_arr[7];
+    let __v_94: G = __r_arr[8];
+    let __v_95: G = __r_arr[9];
+    let __v_96: G = __r_arr[10];
+    let __v_97: G = __r_arr[11];
+    let __v_98: G = __r_arr[12];
+    let __v_99: G = __r_arr[13];
+    let __v_100: G = __r_arr[14];
+    let __v_101: G = __r_arr[15];
+    let __v_102: G = __r_arr[16];
+    let __v_103: G = __r_arr[17];
+    let __v_104: G = __r_arr[18];
+    let __v_105: G = __r_arr[19];
+    let __v_106: G = __r_arr[20];
+    let __v_107: G = __r_arr[21];
+    let __v_108: G = __r_arr[22];
+    let __v_109: G = __r_arr[23];
+    let __v_110: G = __r_arr[24];
+    let __v_111: G = __r_arr[25];
+    let __v_112: G = __r_arr[26];
+    let __v_113: G = __r_arr[27];
+    let __v_114: G = __r_arr[28];
+    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_62] = [__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[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_63: usize = 67;
+const IN_63: usize = 67;
+const OUT_63: usize = 67;
+fn aiur_fn_63(
+  inp: [G; IN_63],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_63], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __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];
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        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_63] = [__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[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __v_67: G = __loaded[0];
+        let __v_68: G = __loaded[1];
+        let __v_69: G = __loaded[2];
+        let __v_70: G = __loaded[3];
+        let __v_71: G = __loaded[4];
+        let __v_72: G = __loaded[5];
+        let __v_73: G = __loaded[6];
+        let __v_74: G = __loaded[7];
+        let __v_75: G = __loaded[8];
+        let __v_76: G = __loaded[9];
+        let __v_77: G = __loaded[10];
+        let __v_78: G = __loaded[11];
+        let __v_79: G = __loaded[12];
+        let __v_80: G = __loaded[13];
+        let __v_81: G = __loaded[14];
+        let __v_82: G = __loaded[15];
+        let __v_83: G = __loaded[16];
+        let __v_84: G = __loaded[17];
+        let __v_85: G = __loaded[18];
+        let __v_86: G = __loaded[19];
+        let __v_87: G = __loaded[20];
+        let __v_88: G = __loaded[21];
+        let __v_89: G = __loaded[22];
+        let __v_90: G = __loaded[23];
+        let __v_91: G = __loaded[24];
+        let __v_92: G = __loaded[25];
+        let __v_93: G = __loaded[26];
+        let __v_94: G = __loaded[27];
+        let __v_95: G = __loaded[28];
+        let __v_96: G = __loaded[29];
+        let __v_97: G = __loaded[30];
+        let __v_98: G = __loaded[31];
+        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_63] = { let __args: [G; IN_63] = [__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[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_102: G = __r_arr[0];
+        let __v_103: G = __r_arr[1];
+        let __v_104: G = __r_arr[2];
+        let __v_105: G = __r_arr[3];
+        let __v_106: G = __r_arr[4];
+        let __v_107: G = __r_arr[5];
+        let __v_108: G = __r_arr[6];
+        let __v_109: G = __r_arr[7];
+        let __v_110: G = __r_arr[8];
+        let __v_111: G = __r_arr[9];
+        let __v_112: G = __r_arr[10];
+        let __v_113: G = __r_arr[11];
+        let __v_114: G = __r_arr[12];
+        let __v_115: G = __r_arr[13];
+        let __v_116: G = __r_arr[14];
+        let __v_117: G = __r_arr[15];
+        let __v_118: G = __r_arr[16];
+        let __v_119: G = __r_arr[17];
+        let __v_120: G = __r_arr[18];
+        let __v_121: G = __r_arr[19];
+        let __v_122: G = __r_arr[20];
+        let __v_123: G = __r_arr[21];
+        let __v_124: G = __r_arr[22];
+        let __v_125: G = __r_arr[23];
+        let __v_126: G = __r_arr[24];
+        let __v_127: G = __r_arr[25];
+        let __v_128: G = __r_arr[26];
+        let __v_129: G = __r_arr[27];
+        let __v_130: G = __r_arr[28];
+        let __v_131: G = __r_arr[29];
+        let __v_132: G = __r_arr[30];
+        let __v_133: G = __r_arr[31];
+        let __v_134: G = __r_arr[32];
+        let __v_135: G = __r_arr[33];
+        let __v_136: G = __r_arr[34];
+        let __v_137: G = __r_arr[35];
+        let __v_138: G = __r_arr[36];
+        let __v_139: G = __r_arr[37];
+        let __v_140: G = __r_arr[38];
+        let __v_141: G = __r_arr[39];
+        let __v_142: G = __r_arr[40];
+        let __v_143: G = __r_arr[41];
+        let __v_144: G = __r_arr[42];
+        let __v_145: G = __r_arr[43];
+        let __v_146: G = __r_arr[44];
+        let __v_147: G = __r_arr[45];
+        let __v_148: G = __r_arr[46];
+        let __v_149: G = __r_arr[47];
+        let __v_150: G = __r_arr[48];
+        let __v_151: G = __r_arr[49];
+        let __v_152: G = __r_arr[50];
+        let __v_153: G = __r_arr[51];
+        let __v_154: G = __r_arr[52];
+        let __v_155: G = __r_arr[53];
+        let __v_156: G = __r_arr[54];
+        let __v_157: G = __r_arr[55];
+        let __v_158: G = __r_arr[56];
+        let __v_159: G = __r_arr[57];
+        let __v_160: G = __r_arr[58];
+        let __v_161: G = __r_arr[59];
+        let __v_162: G = __r_arr[60];
+        let __v_163: G = __r_arr[61];
+        let __v_164: G = __r_arr[62];
+        let __v_165: G = __r_arr[63];
+        let __v_166: G = __r_arr[64];
+        let __v_167: G = __r_arr[65];
+        let __v_168: G = __r_arr[66];
+        match __v_102.as_canonical_u64() {
+          0u64 => {
+            let __v_169: G = G::from_u64(1);
+            let __ret: [G; OUT_63] = [__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[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_169: G = G::from_u64(4);
+            let __v_170: G = G::from_u64(8);
+            let __v_171: G = G::from_u64(103);
+            let __v_172: G = G::from_u64(230);
+            let __v_173: G = G::from_u64(9);
+            let __v_174: G = G::from_u64(106);
+            let __v_175: G = G::from_u64(133);
+            let __v_176: G = G::from_u64(174);
+            let __v_177: G = G::from_u64(103);
+            let __v_178: G = G::from_u64(187);
+            let __v_179: G = G::from_u64(114);
+            let __v_180: G = G::from_u64(243);
+            let __v_181: G = G::from_u64(110);
+            let __v_182: G = G::from_u64(60);
+            let __v_183: G = G::from_u64(58);
+            let __v_184: G = G::from_u64(245);
+            let __v_185: G = G::from_u64(79);
+            let __v_186: G = G::from_u64(165);
+            let __v_187: G = G::from_u64(127);
+            let __v_188: G = G::from_u64(82);
+            let __v_189: G = G::from_u64(14);
+            let __v_190: G = G::from_u64(81);
+            let __v_191: G = G::from_u64(140);
+            let __v_192: G = G::from_u64(104);
+            let __v_193: G = G::from_u64(5);
+            let __v_194: G = G::from_u64(155);
+            let __v_195: G = G::from_u64(171);
+            let __v_196: G = G::from_u64(217);
+            let __v_197: G = G::from_u64(131);
+            let __v_198: G = G::from_u64(31);
+            let __v_199: G = G::from_u64(25);
+            let __v_200: G = G::from_u64(205);
+            let __v_201: G = G::from_u64(224);
+            let __v_202: G = G::from_u64(91);
+            match __v_135.as_canonical_u64() {
+              1u64 => {
+                let __v_203: G = (__v_170 * __v_66);
+                let __v_204: G = (__v_169 + __v_203);
+                let __v_205: G = G::from_u64(0);
+                let __v_206: G = G::from_u64(0);
+                let __v_207: G = G::from_u64(0);
+                let __v_208: G = G::from_u64(0);
+                let __v_209: G = G::from_u64(0);
+                let __v_210: G = G::from_u64(0);
+                let __v_211: G = G::from_u64(0);
+                let __v_212: G = G::from_u64(0);
+                let __v_213: G = G::from_u64(64);
+                let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[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_214: G = __r_arr[0];
+                let __v_215: G = __r_arr[1];
+                let __v_216: G = __r_arr[2];
+                let __v_217: G = __r_arr[3];
+                let __v_218: G = __r_arr[4];
+                let __v_219: G = __r_arr[5];
+                let __v_220: G = __r_arr[6];
+                let __v_221: G = __r_arr[7];
+                let __v_222: G = __r_arr[8];
+                let __v_223: G = __r_arr[9];
+                let __v_224: G = __r_arr[10];
+                let __v_225: G = __r_arr[11];
+                let __v_226: G = __r_arr[12];
+                let __v_227: G = __r_arr[13];
+                let __v_228: G = __r_arr[14];
+                let __v_229: G = __r_arr[15];
+                let __v_230: G = __r_arr[16];
+                let __v_231: G = __r_arr[17];
+                let __v_232: G = __r_arr[18];
+                let __v_233: G = __r_arr[19];
+                let __v_234: G = __r_arr[20];
+                let __v_235: G = __r_arr[21];
+                let __v_236: G = __r_arr[22];
+                let __v_237: G = __r_arr[23];
+                let __v_238: G = __r_arr[24];
+                let __v_239: G = __r_arr[25];
+                let __v_240: G = __r_arr[26];
+                let __v_241: G = __r_arr[27];
+                let __v_242: G = __r_arr[28];
+                let __v_243: G = __r_arr[29];
+                let __v_244: G = __r_arr[30];
+                let __v_245: G = __r_arr[31];
+                let __v_246: G = G::from_u64(0);
+                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_63] = [__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[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_203: G = G::from_u64(0);
+                let __v_204: G = G::from_u64(0);
+                let __v_205: G = G::from_u64(0);
+                let __v_206: G = G::from_u64(0);
+                let __v_207: G = G::from_u64(0);
+                let __v_208: G = G::from_u64(0);
+                let __v_209: G = G::from_u64(0);
+                let __v_210: G = G::from_u64(0);
+                let __v_211: G = G::from_u64(64);
+                let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[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_212: G = __r_arr[0];
+                let __v_213: G = __r_arr[1];
+                let __v_214: G = __r_arr[2];
+                let __v_215: G = __r_arr[3];
+                let __v_216: G = __r_arr[4];
+                let __v_217: G = __r_arr[5];
+                let __v_218: G = __r_arr[6];
+                let __v_219: G = __r_arr[7];
+                let __v_220: G = __r_arr[8];
+                let __v_221: G = __r_arr[9];
+                let __v_222: G = __r_arr[10];
+                let __v_223: G = __r_arr[11];
+                let __v_224: G = __r_arr[12];
+                let __v_225: G = __r_arr[13];
+                let __v_226: G = __r_arr[14];
+                let __v_227: G = __r_arr[15];
+                let __v_228: G = __r_arr[16];
+                let __v_229: G = __r_arr[17];
+                let __v_230: G = __r_arr[18];
+                let __v_231: G = __r_arr[19];
+                let __v_232: G = __r_arr[20];
+                let __v_233: G = __r_arr[21];
+                let __v_234: G = __r_arr[22];
+                let __v_235: G = __r_arr[23];
+                let __v_236: G = __r_arr[24];
+                let __v_237: G = __r_arr[25];
+                let __v_238: G = __r_arr[26];
+                let __v_239: G = __r_arr[27];
+                let __v_240: G = __r_arr[28];
+                let __v_241: G = __r_arr[29];
+                let __v_242: G = __r_arr[30];
+                let __v_243: G = __r_arr[31];
+                let __v_244: G = G::from_u64(0);
+                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_63] = [__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[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_64: usize = 34;
+const IN_64: usize = 34;
+const OUT_64: usize = 32;
+fn aiur_fn_64(
+  inp: [G; IN_64],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_64], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_0.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __v_34: G = __loaded[0];
+        let __v_35: G = __loaded[1];
+        let __v_36: G = __loaded[2];
+        let __v_37: G = __loaded[3];
+        let __v_38: G = __loaded[4];
+        let __v_39: G = __loaded[5];
+        let __v_40: G = __loaded[6];
+        let __v_41: G = __loaded[7];
+        let __v_42: G = __loaded[8];
+        let __v_43: G = __loaded[9];
+        let __v_44: G = __loaded[10];
+        let __v_45: G = __loaded[11];
+        let __v_46: G = __loaded[12];
+        let __v_47: G = __loaded[13];
+        let __v_48: G = __loaded[14];
+        let __v_49: G = __loaded[15];
+        let __v_50: G = __loaded[16];
+        let __v_51: G = __loaded[17];
+        let __v_52: G = __loaded[18];
+        let __v_53: G = __loaded[19];
+        let __v_54: G = __loaded[20];
+        let __v_55: G = __loaded[21];
+        let __v_56: G = __loaded[22];
+        let __v_57: G = __loaded[23];
+        let __v_58: G = __loaded[24];
+        let __v_59: G = __loaded[25];
+        let __v_60: G = __loaded[26];
+        let __v_61: G = __loaded[27];
+        let __v_62: G = __loaded[28];
+        let __v_63: G = __loaded[29];
+        let __v_64: G = __loaded[30];
+        let __v_65: G = __loaded[31];
+        let __v_66: G = __loaded[32];
+        let __v_67: G = __loaded[33];
+        match __v_34.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_64] = [__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[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].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];
+            let __v_80: G = __loaded[12];
+            let __v_81: G = __loaded[13];
+            let __v_82: G = __loaded[14];
+            let __v_83: G = __loaded[15];
+            let __v_84: G = __loaded[16];
+            let __v_85: G = __loaded[17];
+            let __v_86: G = __loaded[18];
+            let __v_87: G = __loaded[19];
+            let __v_88: G = __loaded[20];
+            let __v_89: G = __loaded[21];
+            let __v_90: G = __loaded[22];
+            let __v_91: G = __loaded[23];
+            let __v_92: G = __loaded[24];
+            let __v_93: G = __loaded[25];
+            let __v_94: G = __loaded[26];
+            let __v_95: G = __loaded[27];
+            let __v_96: G = __loaded[28];
+            let __v_97: G = __loaded[29];
+            let __v_98: G = __loaded[30];
+            let __v_99: G = __loaded[31];
+            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_63] = { let __args: [G; IN_63] = [__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[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_103: G = __r_arr[0];
+            let __v_104: G = __r_arr[1];
+            let __v_105: G = __r_arr[2];
+            let __v_106: G = __r_arr[3];
+            let __v_107: G = __r_arr[4];
+            let __v_108: G = __r_arr[5];
+            let __v_109: G = __r_arr[6];
+            let __v_110: G = __r_arr[7];
+            let __v_111: G = __r_arr[8];
+            let __v_112: G = __r_arr[9];
+            let __v_113: G = __r_arr[10];
+            let __v_114: G = __r_arr[11];
+            let __v_115: G = __r_arr[12];
+            let __v_116: G = __r_arr[13];
+            let __v_117: G = __r_arr[14];
+            let __v_118: G = __r_arr[15];
+            let __v_119: G = __r_arr[16];
+            let __v_120: G = __r_arr[17];
+            let __v_121: G = __r_arr[18];
+            let __v_122: G = __r_arr[19];
+            let __v_123: G = __r_arr[20];
+            let __v_124: G = __r_arr[21];
+            let __v_125: G = __r_arr[22];
+            let __v_126: G = __r_arr[23];
+            let __v_127: G = __r_arr[24];
+            let __v_128: G = __r_arr[25];
+            let __v_129: G = __r_arr[26];
+            let __v_130: G = __r_arr[27];
+            let __v_131: G = __r_arr[28];
+            let __v_132: G = __r_arr[29];
+            let __v_133: G = __r_arr[30];
+            let __v_134: G = __r_arr[31];
+            let __v_135: G = __r_arr[32];
+            let __v_136: G = __r_arr[33];
+            let __v_137: G = __r_arr[34];
+            let __v_138: G = __r_arr[35];
+            let __v_139: G = __r_arr[36];
+            let __v_140: G = __r_arr[37];
+            let __v_141: G = __r_arr[38];
+            let __v_142: G = __r_arr[39];
+            let __v_143: G = __r_arr[40];
+            let __v_144: G = __r_arr[41];
+            let __v_145: G = __r_arr[42];
+            let __v_146: G = __r_arr[43];
+            let __v_147: G = __r_arr[44];
+            let __v_148: G = __r_arr[45];
+            let __v_149: G = __r_arr[46];
+            let __v_150: G = __r_arr[47];
+            let __v_151: G = __r_arr[48];
+            let __v_152: G = __r_arr[49];
+            let __v_153: G = __r_arr[50];
+            let __v_154: G = __r_arr[51];
+            let __v_155: G = __r_arr[52];
+            let __v_156: G = __r_arr[53];
+            let __v_157: G = __r_arr[54];
+            let __v_158: G = __r_arr[55];
+            let __v_159: G = __r_arr[56];
+            let __v_160: G = __r_arr[57];
+            let __v_161: G = __r_arr[58];
+            let __v_162: G = __r_arr[59];
+            let __v_163: G = __r_arr[60];
+            let __v_164: G = __r_arr[61];
+            let __v_165: G = __r_arr[62];
+            let __v_166: G = __r_arr[63];
+            let __v_167: G = __r_arr[64];
+            let __v_168: G = __r_arr[65];
+            let __v_169: G = __r_arr[66];
+            match __v_103.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__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[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_170: G = __r_arr[0];
+                let __v_171: G = __r_arr[1];
+                let __v_172: G = __r_arr[2];
+                let __v_173: G = __r_arr[3];
+                let __v_174: G = __r_arr[4];
+                let __v_175: G = __r_arr[5];
+                let __v_176: G = __r_arr[6];
+                let __v_177: G = __r_arr[7];
+                let __v_178: G = __r_arr[8];
+                let __v_179: G = __r_arr[9];
+                let __v_180: G = __r_arr[10];
+                let __v_181: G = __r_arr[11];
+                let __v_182: G = __r_arr[12];
+                let __v_183: G = __r_arr[13];
+                let __v_184: G = __r_arr[14];
+                let __v_185: G = __r_arr[15];
+                let __v_186: G = __r_arr[16];
+                let __v_187: G = __r_arr[17];
+                let __v_188: G = __r_arr[18];
+                let __v_189: G = __r_arr[19];
+                let __v_190: G = __r_arr[20];
+                let __v_191: G = __r_arr[21];
+                let __v_192: G = __r_arr[22];
+                let __v_193: G = __r_arr[23];
+                let __v_194: G = __r_arr[24];
+                let __v_195: G = __r_arr[25];
+                let __v_196: G = __r_arr[26];
+                let __v_197: G = __r_arr[27];
+                let __v_198: G = __r_arr[28];
+                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_64] = [__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[64].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_64] = { let __args: [G; IN_64] = [__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[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_172: G = __r_arr[0];
+                let __v_173: G = __r_arr[1];
+                let __v_174: G = __r_arr[2];
+                let __v_175: G = __r_arr[3];
+                let __v_176: G = __r_arr[4];
+                let __v_177: G = __r_arr[5];
+                let __v_178: G = __r_arr[6];
+                let __v_179: G = __r_arr[7];
+                let __v_180: G = __r_arr[8];
+                let __v_181: G = __r_arr[9];
+                let __v_182: G = __r_arr[10];
+                let __v_183: G = __r_arr[11];
+                let __v_184: G = __r_arr[12];
+                let __v_185: G = __r_arr[13];
+                let __v_186: G = __r_arr[14];
+                let __v_187: G = __r_arr[15];
+                let __v_188: G = __r_arr[16];
+                let __v_189: G = __r_arr[17];
+                let __v_190: G = __r_arr[18];
+                let __v_191: G = __r_arr[19];
+                let __v_192: G = __r_arr[20];
+                let __v_193: G = __r_arr[21];
+                let __v_194: G = __r_arr[22];
+                let __v_195: G = __r_arr[23];
+                let __v_196: G = __r_arr[24];
+                let __v_197: G = __r_arr[25];
+                let __v_198: G = __r_arr[26];
+                let __v_199: G = __r_arr[27];
+                let __v_200: G = __r_arr[28];
+                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_64] = [__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[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_65: usize = 7;
+const IN_65: usize = 7;
+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_65], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __ret: [G; OUT_65] = [__v_10];
+        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        match __v_2.as_canonical_u64() {
+          63u64 => {
+            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_65] = [__v_12];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = (__v_2 + __v_12);
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = (__v_3 + __v_14);
+            let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __ret: [G; OUT_65] = [__v_16];
+            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_66: usize = 1;
+const IN_66: usize = 1;
+const OUT_66: usize = 64;
+fn aiur_fn_66(
+  inp: [G; IN_66],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_66], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_25: G = __loaded[0];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  0u64 => {
+                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                    let __v_97: G = __loaded[0];
+                                                                                                                                    let __v_98: G = __loaded[1];
+                                                                                                                                    let __v_99: G = __loaded[2];
+                                                                                                                                    match __v_97.as_canonical_u64() {
+                                                                                                                                      0u64 => {
+                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                        let __v_100: G = __loaded[0];
+                                                                                                                                        let __v_101: G = __loaded[1];
+                                                                                                                                        let __v_102: G = __loaded[2];
+                                                                                                                                        match __v_100.as_canonical_u64() {
+                                                                                                                                          0u64 => {
+                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                            let __v_103: G = __loaded[0];
+                                                                                                                                            let __v_104: G = __loaded[1];
+                                                                                                                                            let __v_105: G = __loaded[2];
+                                                                                                                                            match __v_103.as_canonical_u64() {
+                                                                                                                                              0u64 => {
+                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                let __v_106: G = __loaded[0];
+                                                                                                                                                let __v_107: G = __loaded[1];
+                                                                                                                                                let __v_108: G = __loaded[2];
+                                                                                                                                                match __v_106.as_canonical_u64() {
+                                                                                                                                                  0u64 => {
+                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                    let __v_109: G = __loaded[0];
+                                                                                                                                                    let __v_110: G = __loaded[1];
+                                                                                                                                                    let __v_111: G = __loaded[2];
+                                                                                                                                                    match __v_109.as_canonical_u64() {
+                                                                                                                                                      0u64 => {
+                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                        let __v_112: G = __loaded[0];
+                                                                                                                                                        let __v_113: G = __loaded[1];
+                                                                                                                                                        let __v_114: G = __loaded[2];
+                                                                                                                                                        match __v_112.as_canonical_u64() {
+                                                                                                                                                          0u64 => {
+                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                            let __v_115: G = __loaded[0];
+                                                                                                                                                            let __v_116: G = __loaded[1];
+                                                                                                                                                            let __v_117: G = __loaded[2];
+                                                                                                                                                            match __v_115.as_canonical_u64() {
+                                                                                                                                                              0u64 => {
+                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                let __v_118: G = __loaded[0];
+                                                                                                                                                                let __v_119: G = __loaded[1];
+                                                                                                                                                                let __v_120: G = __loaded[2];
+                                                                                                                                                                match __v_118.as_canonical_u64() {
+                                                                                                                                                                  0u64 => {
+                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                    let __v_121: G = __loaded[0];
+                                                                                                                                                                    let __v_122: G = __loaded[1];
+                                                                                                                                                                    let __v_123: G = __loaded[2];
+                                                                                                                                                                    match __v_121.as_canonical_u64() {
+                                                                                                                                                                      0u64 => {
+                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                        let __v_124: G = __loaded[0];
+                                                                                                                                                                        let __v_125: G = __loaded[1];
+                                                                                                                                                                        let __v_126: G = __loaded[2];
+                                                                                                                                                                        match __v_124.as_canonical_u64() {
+                                                                                                                                                                          0u64 => {
+                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __v_127: G = __loaded[0];
+                                                                                                                                                                            let __v_128: G = __loaded[1];
+                                                                                                                                                                            let __v_129: G = __loaded[2];
+                                                                                                                                                                            match __v_127.as_canonical_u64() {
+                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __v_130: G = __loaded[0];
+                                                                                                                                                                                let __v_131: G = __loaded[1];
+                                                                                                                                                                                let __v_132: G = __loaded[2];
+                                                                                                                                                                                match __v_130.as_canonical_u64() {
+                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __v_133: G = __loaded[0];
+                                                                                                                                                                                    let __v_134: G = __loaded[1];
+                                                                                                                                                                                    let __v_135: G = __loaded[2];
+                                                                                                                                                                                    match __v_133.as_canonical_u64() {
+                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __v_136: G = __loaded[0];
+                                                                                                                                                                                        let __v_137: G = __loaded[1];
+                                                                                                                                                                                        let __v_138: G = __loaded[2];
+                                                                                                                                                                                        match __v_136.as_canonical_u64() {
+                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __v_139: G = __loaded[0];
+                                                                                                                                                                                            let __v_140: G = __loaded[1];
+                                                                                                                                                                                            let __v_141: G = __loaded[2];
+                                                                                                                                                                                            match __v_139.as_canonical_u64() {
+                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __v_142: G = __loaded[0];
+                                                                                                                                                                                                let __v_143: G = __loaded[1];
+                                                                                                                                                                                                let __v_144: G = __loaded[2];
+                                                                                                                                                                                                match __v_142.as_canonical_u64() {
+                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __v_145: G = __loaded[0];
+                                                                                                                                                                                                    let __v_146: G = __loaded[1];
+                                                                                                                                                                                                    let __v_147: G = __loaded[2];
+                                                                                                                                                                                                    match __v_145.as_canonical_u64() {
+                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __v_148: G = __loaded[0];
+                                                                                                                                                                                                        let __v_149: G = __loaded[1];
+                                                                                                                                                                                                        let __v_150: G = __loaded[2];
+                                                                                                                                                                                                        match __v_148.as_canonical_u64() {
+                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __v_151: G = __loaded[0];
+                                                                                                                                                                                                            let __v_152: G = __loaded[1];
+                                                                                                                                                                                                            let __v_153: G = __loaded[2];
+                                                                                                                                                                                                            match __v_151.as_canonical_u64() {
+                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __v_154: G = __loaded[0];
+                                                                                                                                                                                                                let __v_155: G = __loaded[1];
+                                                                                                                                                                                                                let __v_156: G = __loaded[2];
+                                                                                                                                                                                                                match __v_154.as_canonical_u64() {
+                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __v_157: G = __loaded[0];
+                                                                                                                                                                                                                    let __v_158: G = __loaded[1];
+                                                                                                                                                                                                                    let __v_159: G = __loaded[2];
+                                                                                                                                                                                                                    match __v_157.as_canonical_u64() {
+                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __v_160: G = __loaded[0];
+                                                                                                                                                                                                                        let __v_161: G = __loaded[1];
+                                                                                                                                                                                                                        let __v_162: G = __loaded[2];
+                                                                                                                                                                                                                        match __v_160.as_canonical_u64() {
+                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __v_163: G = __loaded[0];
+                                                                                                                                                                                                                            let __v_164: G = __loaded[1];
+                                                                                                                                                                                                                            let __v_165: G = __loaded[2];
+                                                                                                                                                                                                                            match __v_163.as_canonical_u64() {
+                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __v_166: G = __loaded[0];
+                                                                                                                                                                                                                                let __v_167: G = __loaded[1];
+                                                                                                                                                                                                                                let __v_168: G = __loaded[2];
+                                                                                                                                                                                                                                match __v_166.as_canonical_u64() {
+                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __v_169: G = __loaded[0];
+                                                                                                                                                                                                                                    let __v_170: G = __loaded[1];
+                                                                                                                                                                                                                                    let __v_171: G = __loaded[2];
+                                                                                                                                                                                                                                    match __v_169.as_canonical_u64() {
+                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __v_172: G = __loaded[0];
+                                                                                                                                                                                                                                        let __v_173: G = __loaded[1];
+                                                                                                                                                                                                                                        let __v_174: G = __loaded[2];
+                                                                                                                                                                                                                                        match __v_172.as_canonical_u64() {
+                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __v_175: G = __loaded[0];
+                                                                                                                                                                                                                                            let __v_176: G = __loaded[1];
+                                                                                                                                                                                                                                            let __v_177: G = __loaded[2];
+                                                                                                                                                                                                                                            match __v_175.as_canonical_u64() {
+                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __v_178: G = __loaded[0];
+                                                                                                                                                                                                                                                let __v_179: G = __loaded[1];
+                                                                                                                                                                                                                                                let __v_180: G = __loaded[2];
+                                                                                                                                                                                                                                                match __v_178.as_canonical_u64() {
+                                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __v_181: G = __loaded[0];
+                                                                                                                                                                                                                                                    let __v_182: G = __loaded[1];
+                                                                                                                                                                                                                                                    let __v_183: G = __loaded[2];
+                                                                                                                                                                                                                                                    match __v_181.as_canonical_u64() {
+                                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __v_184: G = __loaded[0];
+                                                                                                                                                                                                                                                        let __v_185: G = __loaded[1];
+                                                                                                                                                                                                                                                        let __v_186: G = __loaded[2];
+                                                                                                                                                                                                                                                        match __v_184.as_canonical_u64() {
+                                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __v_187: G = __loaded[0];
+                                                                                                                                                                                                                                                            let __v_188: G = __loaded[1];
+                                                                                                                                                                                                                                                            let __v_189: G = __loaded[2];
+                                                                                                                                                                                                                                                            match __v_187.as_canonical_u64() {
+                                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __v_190: G = __loaded[0];
+                                                                                                                                                                                                                                                                let __v_191: G = __loaded[1];
+                                                                                                                                                                                                                                                                let __v_192: G = __loaded[2];
+                                                                                                                                                                                                                                                                match __v_190.as_canonical_u64() {
+                                                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_66] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
+                                                                                                                                                                                                                                                                    record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64()));
+                                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64()));
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64()));
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64()));
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64()));
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64()));
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64()));
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64()));
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64()));
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64()));
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64()));
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64()));
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64()));
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64()));
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64()));
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64()));
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64()));
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                }
+                                                                                                                                                                                              },
+                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64()));
+                                                                                                                                                                                              },
+                                                                                                                                                                                            }
+                                                                                                                                                                                          },
+                                                                                                                                                                                          _ => {
+                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64()));
+                                                                                                                                                                                          },
+                                                                                                                                                                                        }
+                                                                                                                                                                                      },
+                                                                                                                                                                                      _ => {
+                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64()));
+                                                                                                                                                                                      },
+                                                                                                                                                                                    }
+                                                                                                                                                                                  },
+                                                                                                                                                                                  _ => {
+                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64()));
+                                                                                                                                                                                  },
+                                                                                                                                                                                }
+                                                                                                                                                                              },
+                                                                                                                                                                              _ => {
+                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64()));
+                                                                                                                                                                              },
+                                                                                                                                                                            }
+                                                                                                                                                                          },
+                                                                                                                                                                          _ => {
+                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
+                                                                                                                                                                          },
+                                                                                                                                                                        }
+                                                                                                                                                                      },
+                                                                                                                                                                      _ => {
+                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
+                                                                                                                                                                      },
+                                                                                                                                                                    }
+                                                                                                                                                                  },
+                                                                                                                                                                  _ => {
+                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
+                                                                                                                                                                  },
+                                                                                                                                                                }
+                                                                                                                                                              },
+                                                                                                                                                              _ => {
+                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
+                                                                                                                                                              },
+                                                                                                                                                            }
+                                                                                                                                                          },
+                                                                                                                                                          _ => {
+                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
+                                                                                                                                                          },
+                                                                                                                                                        }
+                                                                                                                                                      },
+                                                                                                                                                      _ => {
+                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
+                                                                                                                                                      },
+                                                                                                                                                    }
+                                                                                                                                                  },
+                                                                                                                                                  _ => {
+                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
+                                                                                                                                                  },
+                                                                                                                                                }
+                                                                                                                                              },
+                                                                                                                                              _ => {
+                                                                                                                                                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+                                                                                                                                              },
+                                                                                                                                            }
+                                                                                                                                          },
+                                                                                                                                          _ => {
+                                                                                                                                            return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64()));
+                                                                                                                                          },
+                                                                                                                                        }
+                                                                                                                                      },
+                                                                                                                                      _ => {
+                                                                                                                                        return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64()));
+                                                                                                                                      },
+                                                                                                                                    }
+                                                                                                                                  },
+                                                                                                                                  _ => {
+                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
+                                                                                                                                  },
+                                                                                                                                }
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
+                                                                                                                              },
+                                                                                                                            }
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
+                                                                                                                          },
+                                                                                                                        }
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
+                                                                                                                      },
+                                                                                                                    }
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
+                                                                                                                  },
+                                                                                                                }
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
+                                                                                                              },
+                                                                                                            }
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
+                                                                                                          },
+                                                                                                        }
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
+                                                                                                      },
+                                                                                                    }
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
+                                                                                                  },
+                                                                                                }
+                                                                                              },
+                                                                                              _ => {
+                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
+                                                                                              },
+                                                                                            }
+                                                                                          },
+                                                                                          _ => {
+                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
+                                                                                          },
+                                                                                        }
+                                                                                      },
+                                                                                      _ => {
+                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
+                                                                                      },
+                                                                                    }
+                                                                                  },
+                                                                                  _ => {
+                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
+                                                                                  },
+                                                                                }
+                                                                              },
+                                                                              _ => {
+                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+                                                                              },
+                                                                            }
+                                                                          },
+                                                                          _ => {
+                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
+                                                                          },
+                                                                        }
+                                                                      },
+                                                                      _ => {
+                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
+                                                                      },
+                                                                    }
+                                                                  },
+                                                                  _ => {
+                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
+                                                                  },
+                                                                }
+                                                              },
+                                                              _ => {
+                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
+                                                              },
+                                                            }
+                                                          },
+                                                          _ => {
+                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
+                                                          },
+                                                        }
+                                                      },
+                                                      _ => {
+                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
+                                                      },
+                                                    }
+                                                  },
+                                                  _ => {
+                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+                                                  },
+                                                }
+                                              },
+                                              _ => {
+                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+                                              },
+                                            }
+                                          },
+                                          _ => {
+                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_67: usize = 2;
+const IN_67: usize = 2;
+const OUT_67: usize = 1;
+fn aiur_fn_67(
+  inp: [G; IN_67],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_67], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_67] = [__v_0];
+        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_67] = [__v_7];
+        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_68: usize = 6;
+const IN_68: usize = 6;
+const OUT_68: usize = 1;
+fn aiur_fn_68(
+  inp: [G; IN_68],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_68], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = G::from_u64(1);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(8);
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __v_9: G = __loaded[0];
+            let __v_10: G = __loaded[1];
+            let __v_11: G = __loaded[2];
+            let __v_12: G = __loaded[3];
+            let __v_13: G = __loaded[4];
+            let __v_14: G = __loaded[5];
+            let __v_15: G = __loaded[6];
+            let __v_16: G = __loaded[7];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    match __v_11.as_canonical_u64() {
+                      0u64 => {
+                        match __v_12.as_canonical_u64() {
+                          0u64 => {
+                            match __v_13.as_canonical_u64() {
+                              0u64 => {
+                                match __v_14.as_canonical_u64() {
+                                  0u64 => {
+                                    match __v_15.as_canonical_u64() {
+                                      0u64 => {
+                                        match __v_16.as_canonical_u64() {
+                                          0u64 => {
+                                            let __v_17: G = (__v_6 + __v_7);
+                                            let __v_18: G = (__v_8 + __v_17);
+                                            let __v_19: G = G::from_u64(0);
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                            let __v_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 __v_32: G = __loaded[12];
+                                            let __v_33: G = __loaded[13];
+                                            let __v_34: G = __loaded[14];
+                                            let __v_35: G = __loaded[15];
+                                            let __v_36: G = __loaded[16];
+                                            let __v_37: G = __loaded[17];
+                                            let __v_38: G = __loaded[18];
+                                            let __v_39: G = __loaded[19];
+                                            let __v_40: G = __loaded[20];
+                                            let __v_41: G = __loaded[21];
+                                            let __v_42: G = __loaded[22];
+                                            let __v_43: G = __loaded[23];
+                                            let __v_44: G = __loaded[24];
+                                            let __v_45: G = __loaded[25];
+                                            let __v_46: G = __loaded[26];
+                                            let __v_47: G = __loaded[27];
+                                            let __v_48: G = __loaded[28];
+                                            let __v_49: G = __loaded[29];
+                                            let __v_50: G = __loaded[30];
+                                            let __v_51: G = __loaded[31];
+                                            let __v_52: G = G::from_u64(0);
+                                            let __v_53: G = G::from_u64(0);
+                                            let __v_54: G = G::from_u64(0);
+                                            let __v_55: G = G::from_u64(0);
+                                            let __v_56: G = G::from_u64(0);
+                                            let __v_57: G = G::from_u64(0);
+                                            let __v_58: G = G::from_u64(0);
+                                            let __v_59: G = G::from_u64(0);
+                                            let __v_60: G = G::from_u64(0);
+                                            let __v_61: G = G::from_u64(0);
+                                            let __v_62: G = G::from_u64(0);
+                                            let __v_63: G = G::from_u64(0);
+                                            let __v_64: G = G::from_u64(0);
+                                            let __v_65: G = G::from_u64(0);
+                                            let __v_66: G = G::from_u64(0);
+                                            let __v_67: G = G::from_u64(0);
+                                            let __v_68: G = G::from_u64(0);
+                                            let __v_69: G = G::from_u64(0);
+                                            let __v_70: G = G::from_u64(0);
+                                            let __v_71: G = G::from_u64(0);
+                                            let __v_72: G = G::from_u64(0);
+                                            let __v_73: G = G::from_u64(0);
+                                            let __v_74: G = G::from_u64(0);
+                                            let __v_75: G = G::from_u64(0);
+                                            let __v_76: G = G::from_u64(0);
+                                            let __v_77: G = G::from_u64(0);
+                                            let __v_78: G = G::from_u64(0);
+                                            let __v_79: G = G::from_u64(0);
+                                            let __v_80: G = G::from_u64(0);
+                                            let __v_81: G = G::from_u64(0);
+                                            let __v_82: G = G::from_u64(0);
+                                            let __v_83: G = G::from_u64(0);
+                                            let __v_84: G = G::from_u64(0);
+                                            let __v_85: G = G::from_u64(0);
+                                            let __v_86: G = G::from_u64(0);
+                                            let __v_87: G = G::from_u64(0);
+                                            let __v_88: G = G::from_u64(0);
+                                            let __v_89: G = G::from_u64(0);
+                                            let __v_90: G = G::from_u64(0);
+                                            let __v_91: G = G::from_u64(0);
+                                            let __v_92: G = G::from_u64(0);
+                                            let __v_93: G = G::from_u64(0);
+                                            let __v_94: G = G::from_u64(0);
+                                            let __v_95: G = G::from_u64(0);
+                                            let __v_96: G = G::from_u64(0);
+                                            let __v_97: G = G::from_u64(0);
+                                            let __v_98: G = G::from_u64(0);
+                                            let __v_99: G = G::from_u64(0);
+                                            let __v_100: G = G::from_u64(0);
+                                            let __v_101: G = G::from_u64(0);
+                                            let __v_102: G = G::from_u64(0);
+                                            let __v_103: G = G::from_u64(0);
+                                            let __v_104: G = G::from_u64(0);
+                                            let __v_105: G = G::from_u64(0);
+                                            let __v_106: G = G::from_u64(0);
+                                            let __v_107: G = G::from_u64(0);
+                                            let __v_108: G = G::from_u64(0);
+                                            let __v_109: G = G::from_u64(0);
+                                            let __v_110: G = G::from_u64(0);
+                                            let __v_111: G = G::from_u64(0);
+                                            let __v_112: G = G::from_u64(0);
+                                            let __v_113: G = G::from_u64(0);
+                                            let __v_114: G = G::from_u64(0);
+                                            let __v_115: G = G::from_u64(0);
+                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __v_116: G = __loaded[0];
+                                            let __v_117: G = __loaded[1];
+                                            let __v_118: G = __loaded[2];
+                                            let __v_119: G = __loaded[3];
+                                            let __v_120: G = __loaded[4];
+                                            let __v_121: G = __loaded[5];
+                                            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_72] = { let __args: [G; IN_72] = [__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[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_125: G = __r_arr[0];
+                                            let __v_126: G = __r_arr[1];
+                                            let __v_127: G = __r_arr[2];
+                                            let __v_128: G = __r_arr[3];
+                                            let __v_129: G = __r_arr[4];
+                                            let __v_130: G = __r_arr[5];
+                                            let __v_131: G = __r_arr[6];
+                                            let __v_132: G = __r_arr[7];
+                                            let __v_133: G = __r_arr[8];
+                                            let __v_134: G = __r_arr[9];
+                                            let __v_135: G = __r_arr[10];
+                                            let __v_136: G = __r_arr[11];
+                                            let __v_137: G = __r_arr[12];
+                                            let __v_138: G = __r_arr[13];
+                                            let __v_139: G = __r_arr[14];
+                                            let __v_140: G = __r_arr[15];
+                                            let __v_141: G = __r_arr[16];
+                                            let __v_142: G = __r_arr[17];
+                                            let __v_143: G = __r_arr[18];
+                                            let __v_144: G = __r_arr[19];
+                                            let __v_145: G = __r_arr[20];
+                                            let __v_146: G = __r_arr[21];
+                                            let __v_147: G = __r_arr[22];
+                                            let __v_148: G = __r_arr[23];
+                                            let __v_149: G = __r_arr[24];
+                                            let __v_150: G = __r_arr[25];
+                                            let __v_151: G = __r_arr[26];
+                                            let __v_152: G = __r_arr[27];
+                                            let __v_153: G = __r_arr[28];
+                                            let __v_154: G = __r_arr[29];
+                                            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_68] = [__v_157];
+                                            record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __ret: [G; OUT_68] = [__v_5];
+                                            record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_68] = [__v_5];
+                                        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_68] = [__v_5];
+                                    record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_68] = [__v_5];
+                                record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_68] = [__v_5];
+                            record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_68] = [__v_5];
+                        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_68] = [__v_5];
+                    record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_68] = [__v_5];
+                record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_9: G = G::from_u64(0);
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            let __v_13: G = __loaded[3];
+            let __v_14: G = __loaded[4];
+            let __v_15: G = __loaded[5];
+            let __v_16: G = __loaded[6];
+            let __v_17: G = __loaded[7];
+            let __v_18: G = __loaded[8];
+            let __v_19: G = __loaded[9];
+            let __v_20: G = __loaded[10];
+            let __v_21: G = __loaded[11];
+            let __v_22: G = __loaded[12];
+            let __v_23: G = __loaded[13];
+            let __v_24: G = __loaded[14];
+            let __v_25: G = __loaded[15];
+            let __v_26: G = __loaded[16];
+            let __v_27: G = __loaded[17];
+            let __v_28: G = __loaded[18];
+            let __v_29: G = __loaded[19];
+            let __v_30: G = __loaded[20];
+            let __v_31: G = __loaded[21];
+            let __v_32: G = __loaded[22];
+            let __v_33: G = __loaded[23];
+            let __v_34: G = __loaded[24];
+            let __v_35: G = __loaded[25];
+            let __v_36: G = __loaded[26];
+            let __v_37: G = __loaded[27];
+            let __v_38: G = __loaded[28];
+            let __v_39: G = __loaded[29];
+            let __v_40: G = __loaded[30];
+            let __v_41: G = __loaded[31];
+            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_68] = [__v_42];
+            record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        let __v_13: G = __loaded[4];
+        let __v_14: G = __loaded[5];
+        let __v_15: G = __loaded[6];
+        let __v_16: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = (__v_17 * __v_8);
+        let __v_19: G = (__v_2 - __v_1);
+        let __v_20: G = G::from_bool((__v_19 == G::ZERO));
+        let __v_21: G = (__v_20 * __v_6);
+        let __v_22: G = (__v_18 + __v_21);
+        let __v_23: G = (__v_7 + __v_22);
+        let __v_24: G = G::from_u64(64);
+        let __v_25: G = (__v_24 - __v_1);
+        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+        let __v_26: G = __r_arr[0];
+        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __v_28: G = __r_arr[1];
+        let __v_29: G = __r_arr[2];
+        let __v_30: G = __r_arr[3];
+        let __v_31: G = __r_arr[4];
+        let __v_32: G = __r_arr[5];
+        let __v_33: G = __r_arr[6];
+        let __v_34: G = __r_arr[7];
+        let __v_35: G = __r_arr[8];
+        let __v_36: G = __r_arr[9];
+        let __v_37: G = __r_arr[10];
+        let __v_38: G = __r_arr[11];
+        let __v_39: G = __r_arr[12];
+        let __v_40: G = __r_arr[13];
+        let __v_41: G = __r_arr[14];
+        let __v_42: G = __r_arr[15];
+        let __v_43: G = __r_arr[16];
+        let __v_44: G = __r_arr[17];
+        let __v_45: G = __r_arr[18];
+        let __v_46: G = __r_arr[19];
+        let __v_47: G = __r_arr[20];
+        let __v_48: G = __r_arr[21];
+        let __v_49: G = __r_arr[22];
+        let __v_50: G = __r_arr[23];
+        let __v_51: G = __r_arr[24];
+        let __v_52: G = __r_arr[25];
+        let __v_53: G = __r_arr[26];
+        let __v_54: G = __r_arr[27];
+        let __v_55: G = __r_arr[28];
+        let __v_56: G = __r_arr[29];
+        let __v_57: G = __r_arr[30];
+        let __v_58: G = __r_arr[31];
+        let __v_59: G = __r_arr[32];
+        let __v_60: G = __r_arr[33];
+        let __v_61: G = __r_arr[34];
+        let __v_62: G = __r_arr[35];
+        let __v_63: G = __r_arr[36];
+        let __v_64: G = __r_arr[37];
+        let __v_65: G = __r_arr[38];
+        let __v_66: G = __r_arr[39];
+        let __v_67: G = __r_arr[40];
+        let __v_68: G = __r_arr[41];
+        let __v_69: G = __r_arr[42];
+        let __v_70: G = __r_arr[43];
+        let __v_71: G = __r_arr[44];
+        let __v_72: G = __r_arr[45];
+        let __v_73: G = __r_arr[46];
+        let __v_74: G = __r_arr[47];
+        let __v_75: G = __r_arr[48];
+        let __v_76: G = __r_arr[49];
+        let __v_77: G = __r_arr[50];
+        let __v_78: G = __r_arr[51];
+        let __v_79: G = __r_arr[52];
+        let __v_80: G = __r_arr[53];
+        let __v_81: G = __r_arr[54];
+        let __v_82: G = __r_arr[55];
+        let __v_83: G = __r_arr[56];
+        let __v_84: G = __r_arr[57];
+        let __v_85: G = __r_arr[58];
+        let __v_86: G = __r_arr[59];
+        let __v_87: G = __r_arr[60];
+        let __v_88: G = __r_arr[61];
+        let __v_89: G = __r_arr[62];
+        let __v_90: G = __r_arr[63];
+        let __v_91: G = G::from_u64(0);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_92: G = __loaded[0];
+        let __v_93: G = __loaded[1];
+        let __v_94: G = __loaded[2];
+        let __v_95: G = __loaded[3];
+        let __v_96: G = __loaded[4];
+        let __v_97: G = __loaded[5];
+        let __v_98: G = __loaded[6];
+        let __v_99: G = __loaded[7];
+        let __v_100: G = __loaded[8];
+        let __v_101: G = __loaded[9];
+        let __v_102: G = __loaded[10];
+        let __v_103: G = __loaded[11];
+        let __v_104: G = __loaded[12];
+        let __v_105: G = __loaded[13];
+        let __v_106: G = __loaded[14];
+        let __v_107: G = __loaded[15];
+        let __v_108: G = __loaded[16];
+        let __v_109: G = __loaded[17];
+        let __v_110: G = __loaded[18];
+        let __v_111: G = __loaded[19];
+        let __v_112: G = __loaded[20];
+        let __v_113: G = __loaded[21];
+        let __v_114: G = __loaded[22];
+        let __v_115: G = __loaded[23];
+        let __v_116: G = __loaded[24];
+        let __v_117: G = __loaded[25];
+        let __v_118: G = __loaded[26];
+        let __v_119: G = __loaded[27];
+        let __v_120: G = __loaded[28];
+        let __v_121: G = __loaded[29];
+        let __v_122: G = __loaded[30];
+        let __v_123: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_124: G = __loaded[0];
+        let __v_125: G = __loaded[1];
+        let __v_126: G = __loaded[2];
+        let __v_127: G = __loaded[3];
+        let __v_128: G = __loaded[4];
+        let __v_129: G = __loaded[5];
+        let __v_130: G = __loaded[6];
+        let __v_131: G = __loaded[7];
+        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[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_132: G = __r_arr[0];
+        let __v_133: G = __r_arr[1];
+        let __v_134: G = __r_arr[2];
+        let __v_135: G = __r_arr[3];
+        let __v_136: G = __r_arr[4];
+        let __v_137: G = __r_arr[5];
+        let __v_138: G = __r_arr[6];
+        let __v_139: G = __r_arr[7];
+        let __v_140: G = __r_arr[8];
+        let __v_141: G = __r_arr[9];
+        let __v_142: G = __r_arr[10];
+        let __v_143: G = __r_arr[11];
+        let __v_144: G = __r_arr[12];
+        let __v_145: G = __r_arr[13];
+        let __v_146: G = __r_arr[14];
+        let __v_147: G = __r_arr[15];
+        let __v_148: G = __r_arr[16];
+        let __v_149: G = __r_arr[17];
+        let __v_150: G = __r_arr[18];
+        let __v_151: G = __r_arr[19];
+        let __v_152: G = __r_arr[20];
+        let __v_153: G = __r_arr[21];
+        let __v_154: G = __r_arr[22];
+        let __v_155: G = __r_arr[23];
+        let __v_156: G = __r_arr[24];
+        let __v_157: G = __r_arr[25];
+        let __v_158: G = __r_arr[26];
+        let __v_159: G = __r_arr[27];
+        let __v_160: G = __r_arr[28];
+        let __v_161: G = __r_arr[29];
+        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_68] = [__v_164];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_69: usize = 6;
+const IN_69: usize = 6;
+const OUT_69: usize = 1;
+fn aiur_fn_69(
+  inp: [G; IN_69],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_69], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = G::from_u64(1);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(8);
+    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __v_11: G = __r_arr[2];
+    let __v_12: G = __r_arr[3];
+    let __v_13: G = __r_arr[4];
+    let __v_14: G = __r_arr[5];
+    let __v_15: G = __r_arr[6];
+    let __v_16: G = __r_arr[7];
+    let __v_17: G = __r_arr[8];
+    let __v_18: G = __r_arr[9];
+    let __v_19: G = __r_arr[10];
+    let __v_20: G = __r_arr[11];
+    let __v_21: G = __r_arr[12];
+    let __v_22: G = __r_arr[13];
+    let __v_23: G = __r_arr[14];
+    let __v_24: G = __r_arr[15];
+    let __v_25: G = __r_arr[16];
+    let __v_26: G = __r_arr[17];
+    let __v_27: G = __r_arr[18];
+    let __v_28: G = __r_arr[19];
+    let __v_29: G = __r_arr[20];
+    let __v_30: G = __r_arr[21];
+    let __v_31: G = __r_arr[22];
+    let __v_32: G = __r_arr[23];
+    let __v_33: G = __r_arr[24];
+    let __v_34: G = __r_arr[25];
+    let __v_35: G = __r_arr[26];
+    let __v_36: G = __r_arr[27];
+    let __v_37: G = __r_arr[28];
+    let __v_38: G = __r_arr[29];
+    let __v_39: G = __r_arr[30];
+    let __v_40: G = __r_arr[31];
+    let __v_41: G = __r_arr[32];
+    let __v_42: G = __r_arr[33];
+    let __v_43: G = __r_arr[34];
+    let __v_44: G = __r_arr[35];
+    let __v_45: G = __r_arr[36];
+    let __v_46: G = __r_arr[37];
+    let __v_47: G = __r_arr[38];
+    let __v_48: G = __r_arr[39];
+    let __v_49: G = __r_arr[40];
+    let __v_50: G = __r_arr[41];
+    let __v_51: G = __r_arr[42];
+    let __v_52: G = __r_arr[43];
+    let __v_53: G = __r_arr[44];
+    let __v_54: G = __r_arr[45];
+    let __v_55: G = __r_arr[46];
+    let __v_56: G = __r_arr[47];
+    let __v_57: G = __r_arr[48];
+    let __v_58: G = __r_arr[49];
+    let __v_59: G = __r_arr[50];
+    let __v_60: G = __r_arr[51];
+    let __v_61: G = __r_arr[52];
+    let __v_62: G = __r_arr[53];
+    let __v_63: G = __r_arr[54];
+    let __v_64: G = __r_arr[55];
+    let __v_65: G = __r_arr[56];
+    let __v_66: G = __r_arr[57];
+    let __v_67: G = __r_arr[58];
+    let __v_68: G = __r_arr[59];
+    let __v_69: G = __r_arr[60];
+    let __v_70: G = __r_arr[61];
+    let __v_71: G = __r_arr[62];
+    let __v_72: G = __r_arr[63];
+    match __v_2.as_canonical_u64() {
+      1023u64 => {
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0]; 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_73: G = __r_arr[0];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_74: G = __loaded[0];
+        let __v_75: G = __loaded[1];
+        let __v_76: G = __loaded[2];
+        let __v_77: G = __loaded[3];
+        let __v_78: G = __loaded[4];
+        let __v_79: G = __loaded[5];
+        let __v_80: G = __loaded[6];
+        let __v_81: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_82: G = __r_arr[0];
+        let __v_83: G = (__v_73 * __v_82);
+        let __v_84: G = (__v_8 * __v_83);
+        let __v_85: G = (__v_84 + __v_7);
+        let __v_86: G = G::from_u64(103);
+        let __v_87: G = G::from_u64(230);
+        let __v_88: G = G::from_u64(9);
+        let __v_89: G = G::from_u64(106);
+        let __v_90: G = G::from_u64(133);
+        let __v_91: G = G::from_u64(174);
+        let __v_92: G = G::from_u64(103);
+        let __v_93: G = G::from_u64(187);
+        let __v_94: G = G::from_u64(114);
+        let __v_95: G = G::from_u64(243);
+        let __v_96: G = G::from_u64(110);
+        let __v_97: G = G::from_u64(60);
+        let __v_98: G = G::from_u64(58);
+        let __v_99: G = G::from_u64(245);
+        let __v_100: G = G::from_u64(79);
+        let __v_101: G = G::from_u64(165);
+        let __v_102: G = G::from_u64(127);
+        let __v_103: G = G::from_u64(82);
+        let __v_104: G = G::from_u64(14);
+        let __v_105: G = G::from_u64(81);
+        let __v_106: G = G::from_u64(140);
+        let __v_107: G = G::from_u64(104);
+        let __v_108: G = G::from_u64(5);
+        let __v_109: G = G::from_u64(155);
+        let __v_110: G = G::from_u64(171);
+        let __v_111: G = G::from_u64(217);
+        let __v_112: G = G::from_u64(131);
+        let __v_113: G = G::from_u64(31);
+        let __v_114: G = G::from_u64(25);
+        let __v_115: G = G::from_u64(205);
+        let __v_116: G = G::from_u64(224);
+        let __v_117: G = G::from_u64(91);
+        let __v_118: G = G::from_u64(0);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_119: G = __loaded[0];
+        let __v_120: G = __loaded[1];
+        let __v_121: G = __loaded[2];
+        let __v_122: G = __loaded[3];
+        let __v_123: G = __loaded[4];
+        let __v_124: G = __loaded[5];
+        let __v_125: G = __loaded[6];
+        let __v_126: G = __loaded[7];
+        let __v_127: G = __loaded[8];
+        let __v_128: G = __loaded[9];
+        let __v_129: G = __loaded[10];
+        let __v_130: G = __loaded[11];
+        let __v_131: G = __loaded[12];
+        let __v_132: G = __loaded[13];
+        let __v_133: G = __loaded[14];
+        let __v_134: G = __loaded[15];
+        let __v_135: G = __loaded[16];
+        let __v_136: G = __loaded[17];
+        let __v_137: G = __loaded[18];
+        let __v_138: G = __loaded[19];
+        let __v_139: G = __loaded[20];
+        let __v_140: G = __loaded[21];
+        let __v_141: G = __loaded[22];
+        let __v_142: G = __loaded[23];
+        let __v_143: G = __loaded[24];
+        let __v_144: G = __loaded[25];
+        let __v_145: G = __loaded[26];
+        let __v_146: G = __loaded[27];
+        let __v_147: G = __loaded[28];
+        let __v_148: G = __loaded[29];
+        let __v_149: G = __loaded[30];
+        let __v_150: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_151: G = __loaded[0];
+        let __v_152: G = __loaded[1];
+        let __v_153: G = __loaded[2];
+        let __v_154: G = __loaded[3];
+        let __v_155: G = __loaded[4];
+        let __v_156: G = __loaded[5];
+        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_72] = { let __args: [G; IN_72] = [__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[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_160: G = __r_arr[0];
+        let __v_161: G = __r_arr[1];
+        let __v_162: G = __r_arr[2];
+        let __v_163: G = __r_arr[3];
+        let __v_164: G = __r_arr[4];
+        let __v_165: G = __r_arr[5];
+        let __v_166: G = __r_arr[6];
+        let __v_167: G = __r_arr[7];
+        let __v_168: G = __r_arr[8];
+        let __v_169: G = __r_arr[9];
+        let __v_170: G = __r_arr[10];
+        let __v_171: G = __r_arr[11];
+        let __v_172: G = __r_arr[12];
+        let __v_173: G = __r_arr[13];
+        let __v_174: G = __r_arr[14];
+        let __v_175: G = __r_arr[15];
+        let __v_176: G = __r_arr[16];
+        let __v_177: G = __r_arr[17];
+        let __v_178: G = __r_arr[18];
+        let __v_179: G = __r_arr[19];
+        let __v_180: G = __r_arr[20];
+        let __v_181: G = __r_arr[21];
+        let __v_182: G = __r_arr[22];
+        let __v_183: G = __r_arr[23];
+        let __v_184: G = __r_arr[24];
+        let __v_185: G = __r_arr[25];
+        let __v_186: G = __r_arr[26];
+        let __v_187: G = __r_arr[27];
+        let __v_188: G = __r_arr[28];
+        let __v_189: G = __r_arr[29];
+        let __v_190: G = __r_arr[30];
+        let __v_191: G = __r_arr[31];
+        let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_193: G = G::from_u64(1);
+        let __v_194: G = G::from_u64(1);
+        let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __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 = G::from_u64(0);
+        let __v_197: G = G::from_u64(0);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_198: G = __loaded[0];
+        let __v_199: G = __loaded[1];
+        let __v_200: G = __loaded[2];
+        let __v_201: G = __loaded[3];
+        let __v_202: G = __loaded[4];
+        let __v_203: G = __loaded[5];
+        let __v_204: G = __loaded[6];
+        let __v_205: G = __loaded[7];
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__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];
+        let __v_209: G = __r_arr[3];
+        let __v_210: G = __r_arr[4];
+        let __v_211: G = __r_arr[5];
+        let __v_212: G = __r_arr[6];
+        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_65] = { let __args: [G; IN_65] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; 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_216: G = __r_arr[0];
+        let __ret: [G; OUT_69] = [__v_216];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_73: G = __r_arr[0];
+        let __v_74: G = (__v_73 * __v_7);
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_75: G = __r_arr[0];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_76: G = __loaded[0];
+        let __v_77: G = __loaded[1];
+        let __v_78: G = __loaded[2];
+        let __v_79: G = __loaded[3];
+        let __v_80: G = __loaded[4];
+        let __v_81: G = __loaded[5];
+        let __v_82: G = __loaded[6];
+        let __v_83: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_84: G = __r_arr[0];
+        let __v_85: G = (__v_84 * __v_8);
+        let __v_86: G = (__v_75 * __v_85);
+        let __v_87: G = G::from_u64(63);
+        let __v_88: G = (__v_2 - __v_87);
+        let __v_89: G = G::from_bool((__v_88 == G::ZERO));
+        let __v_90: G = (__v_89 * __v_6);
+        let __v_91: G = (__v_86 + __v_90);
+        let __v_92: G = (__v_74 + __v_91);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_93: G = __loaded[0];
+        let __v_94: G = __loaded[1];
+        let __v_95: G = __loaded[2];
+        let __v_96: G = __loaded[3];
+        let __v_97: G = __loaded[4];
+        let __v_98: G = __loaded[5];
+        let __v_99: G = __loaded[6];
+        let __v_100: G = __loaded[7];
+        let __v_101: G = __loaded[8];
+        let __v_102: G = __loaded[9];
+        let __v_103: G = __loaded[10];
+        let __v_104: G = __loaded[11];
+        let __v_105: G = __loaded[12];
+        let __v_106: G = __loaded[13];
+        let __v_107: G = __loaded[14];
+        let __v_108: G = __loaded[15];
+        let __v_109: G = __loaded[16];
+        let __v_110: G = __loaded[17];
+        let __v_111: G = __loaded[18];
+        let __v_112: G = __loaded[19];
+        let __v_113: G = __loaded[20];
+        let __v_114: G = __loaded[21];
+        let __v_115: G = __loaded[22];
+        let __v_116: G = __loaded[23];
+        let __v_117: G = __loaded[24];
+        let __v_118: G = __loaded[25];
+        let __v_119: G = __loaded[26];
+        let __v_120: G = __loaded[27];
+        let __v_121: G = __loaded[28];
+        let __v_122: G = __loaded[29];
+        let __v_123: G = __loaded[30];
+        let __v_124: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_125: G = __loaded[0];
+        let __v_126: G = __loaded[1];
+        let __v_127: G = __loaded[2];
+        let __v_128: G = __loaded[3];
+        let __v_129: G = __loaded[4];
+        let __v_130: G = __loaded[5];
+        let __v_131: G = __loaded[6];
+        let __v_132: G = __loaded[7];
+        let __v_133: G = G::from_u64(64);
+        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[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_134: G = __r_arr[0];
+        let __v_135: G = __r_arr[1];
+        let __v_136: G = __r_arr[2];
+        let __v_137: G = __r_arr[3];
+        let __v_138: G = __r_arr[4];
+        let __v_139: G = __r_arr[5];
+        let __v_140: G = __r_arr[6];
+        let __v_141: G = __r_arr[7];
+        let __v_142: G = __r_arr[8];
+        let __v_143: G = __r_arr[9];
+        let __v_144: G = __r_arr[10];
+        let __v_145: G = __r_arr[11];
+        let __v_146: G = __r_arr[12];
+        let __v_147: G = __r_arr[13];
+        let __v_148: G = __r_arr[14];
+        let __v_149: G = __r_arr[15];
+        let __v_150: G = __r_arr[16];
+        let __v_151: G = __r_arr[17];
+        let __v_152: G = __r_arr[18];
+        let __v_153: G = __r_arr[19];
+        let __v_154: G = __r_arr[20];
+        let __v_155: G = __r_arr[21];
+        let __v_156: G = __r_arr[22];
+        let __v_157: G = __r_arr[23];
+        let __v_158: G = __r_arr[24];
+        let __v_159: G = __r_arr[25];
+        let __v_160: G = __r_arr[26];
+        let __v_161: G = __r_arr[27];
+        let __v_162: G = __r_arr[28];
+        let __v_163: G = __r_arr[29];
+        let __v_164: G = __r_arr[30];
+        let __v_165: G = __r_arr[31];
+        let __v_166: G = G::from_u64(1);
+        let __v_167: G = G::from_u64(1);
+        let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __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 = G::from_u64(0);
+        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_65] = { let __args: [G; IN_65] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; 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_173: G = __r_arr[0];
+        let __ret: [G; OUT_69] = [__v_173];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_70: usize = 24;
+const IN_70: usize = 24;
+const OUT_70: usize = 16;
+fn aiur_fn_70(
+  inp: [G; IN_70],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_70], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) };
+    let __v_24: G = __b2_add.0;
+    let __v_25: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) };
+    let __v_26: G = __b2_add.0;
+    let __v_27: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_26, &__v_25) } else { bytes2_add_value(__v_26, __v_25, record) };
+    let __v_28: G = __b2_add.0;
+    let __v_29: G = __b2_add.1;
+    let __v_30: G = (__v_27 + __v_29);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) };
+    let __v_31: G = __b2_add.0;
+    let __v_32: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_31, &__v_30) } else { bytes2_add_value(__v_31, __v_30, record) };
+    let __v_33: G = __b2_add.0;
+    let __v_34: G = __b2_add.1;
+    let __v_35: G = (__v_32 + __v_34);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) };
+    let __v_36: G = __b2_add.0;
+    let __v_37: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_36, &__v_35) } else { bytes2_add_value(__v_36, __v_35, record) };
+    let __v_38: G = __b2_add.0;
+    let __v_39: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_24, &__v_16) } else { bytes2_add_value(__v_24, __v_16, record) };
+    let __v_40: G = __b2_add.0;
+    let __v_41: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_28, &__v_17) } else { bytes2_add_value(__v_28, __v_17, record) };
+    let __v_42: G = __b2_add.0;
+    let __v_43: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_42, &__v_41) } else { bytes2_add_value(__v_42, __v_41, record) };
+    let __v_44: G = __b2_add.0;
+    let __v_45: G = __b2_add.1;
+    let __v_46: G = (__v_43 + __v_45);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_18) } else { bytes2_add_value(__v_33, __v_18, record) };
+    let __v_47: G = __b2_add.0;
+    let __v_48: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_47, &__v_46) } else { bytes2_add_value(__v_47, __v_46, record) };
+    let __v_49: G = __b2_add.0;
+    let __v_50: G = __b2_add.1;
+    let __v_51: G = (__v_48 + __v_50);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_38, &__v_19) } else { bytes2_add_value(__v_38, __v_19, record) };
+    let __v_52: G = __b2_add.0;
+    let __v_53: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_52, &__v_51) } else { bytes2_add_value(__v_52, __v_51, record) };
+    let __v_54: G = __b2_add.0;
+    let __v_55: G = __b2_add.1;
+    let __v_56: G = if unconstrained { Bytes2::xor(&__v_12, &__v_40) } else { bytes2_xor_value(__v_12, __v_40, record) };
+    let __v_57: G = if unconstrained { Bytes2::xor(&__v_13, &__v_44) } else { bytes2_xor_value(__v_13, __v_44, record) };
+    let __v_58: G = if unconstrained { Bytes2::xor(&__v_14, &__v_49) } else { bytes2_xor_value(__v_14, __v_49, record) };
+    let __v_59: G = if unconstrained { Bytes2::xor(&__v_15, &__v_54) } else { bytes2_xor_value(__v_15, __v_54, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_8, &__v_58) } else { bytes2_add_value(__v_8, __v_58, record) };
+    let __v_60: G = __b2_add.0;
+    let __v_61: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_9, &__v_59) } else { bytes2_add_value(__v_9, __v_59, record) };
+    let __v_62: G = __b2_add.0;
+    let __v_63: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_62, &__v_61) } else { bytes2_add_value(__v_62, __v_61, record) };
+    let __v_64: G = __b2_add.0;
+    let __v_65: G = __b2_add.1;
+    let __v_66: G = (__v_63 + __v_65);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_56) } else { bytes2_add_value(__v_10, __v_56, record) };
+    let __v_67: G = __b2_add.0;
+    let __v_68: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_67, &__v_66) } else { bytes2_add_value(__v_67, __v_66, record) };
+    let __v_69: G = __b2_add.0;
+    let __v_70: G = __b2_add.1;
+    let __v_71: G = (__v_68 + __v_70);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_11, &__v_57) } else { bytes2_add_value(__v_11, __v_57, record) };
+    let __v_72: G = __b2_add.0;
+    let __v_73: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_72, &__v_71) } else { bytes2_add_value(__v_72, __v_71, record) };
+    let __v_74: G = __b2_add.0;
+    let __v_75: G = __b2_add.1;
+    let __v_76: G = if unconstrained { Bytes2::xor(&__v_4, &__v_60) } else { bytes2_xor_value(__v_4, __v_60, record) };
+    let __v_77: G = if unconstrained { Bytes2::xor(&__v_5, &__v_64) } else { bytes2_xor_value(__v_5, __v_64, record) };
+    let __v_78: G = if unconstrained { Bytes2::xor(&__v_6, &__v_69) } else { bytes2_xor_value(__v_6, __v_69, record) };
+    let __v_79: G = if unconstrained { Bytes2::xor(&__v_7, &__v_74) } else { bytes2_xor_value(__v_7, __v_74, record) };
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_77, &__v_78) } else { bytes2_chain_rotr4_value(__v_77, __v_78, record) };
+    let __v_80: G = __b2_out.0;
+    let __v_81: G = __b2_out.1;
+    let __v_82: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_79, &__v_76) } else { bytes2_chain_rotr4_value(__v_79, __v_76, record) };
+    let __v_83: G = __b2_out.0;
+    let __v_84: G = __b2_out.1;
+    let __v_85: G = __b2_out.2;
+    let __v_86: G = (__v_81 + __v_85);
+    let __v_87: G = (__v_84 + __v_82);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_40, &__v_80) } else { bytes2_add_value(__v_40, __v_80, record) };
+    let __v_88: G = __b2_add.0;
+    let __v_89: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_44, &__v_86) } else { bytes2_add_value(__v_44, __v_86, record) };
+    let __v_90: G = __b2_add.0;
+    let __v_91: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_90, &__v_89) } else { bytes2_add_value(__v_90, __v_89, record) };
+    let __v_92: G = __b2_add.0;
+    let __v_93: G = __b2_add.1;
+    let __v_94: G = (__v_91 + __v_93);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_49, &__v_83) } else { bytes2_add_value(__v_49, __v_83, record) };
+    let __v_95: G = __b2_add.0;
+    let __v_96: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_95, &__v_94) } else { bytes2_add_value(__v_95, __v_94, record) };
+    let __v_97: G = __b2_add.0;
+    let __v_98: G = __b2_add.1;
+    let __v_99: G = (__v_96 + __v_98);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_54, &__v_87) } else { bytes2_add_value(__v_54, __v_87, record) };
+    let __v_100: G = __b2_add.0;
+    let __v_101: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_100, &__v_99) } else { bytes2_add_value(__v_100, __v_99, record) };
+    let __v_102: G = __b2_add.0;
+    let __v_103: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_88, &__v_20) } else { bytes2_add_value(__v_88, __v_20, record) };
+    let __v_104: G = __b2_add.0;
+    let __v_105: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_92, &__v_21) } else { bytes2_add_value(__v_92, __v_21, record) };
+    let __v_106: G = __b2_add.0;
+    let __v_107: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_106, &__v_105) } else { bytes2_add_value(__v_106, __v_105, record) };
+    let __v_108: G = __b2_add.0;
+    let __v_109: G = __b2_add.1;
+    let __v_110: G = (__v_107 + __v_109);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_97, &__v_22) } else { bytes2_add_value(__v_97, __v_22, record) };
+    let __v_111: G = __b2_add.0;
+    let __v_112: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_111, &__v_110) } else { bytes2_add_value(__v_111, __v_110, record) };
+    let __v_113: G = __b2_add.0;
+    let __v_114: G = __b2_add.1;
+    let __v_115: G = (__v_112 + __v_114);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_102, &__v_23) } else { bytes2_add_value(__v_102, __v_23, record) };
+    let __v_116: G = __b2_add.0;
+    let __v_117: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_116, &__v_115) } else { bytes2_add_value(__v_116, __v_115, record) };
+    let __v_118: G = __b2_add.0;
+    let __v_119: G = __b2_add.1;
+    let __v_120: G = if unconstrained { Bytes2::xor(&__v_58, &__v_104) } else { bytes2_xor_value(__v_58, __v_104, record) };
+    let __v_121: G = if unconstrained { Bytes2::xor(&__v_59, &__v_108) } else { bytes2_xor_value(__v_59, __v_108, record) };
+    let __v_122: G = if unconstrained { Bytes2::xor(&__v_56, &__v_113) } else { bytes2_xor_value(__v_56, __v_113, record) };
+    let __v_123: G = if unconstrained { Bytes2::xor(&__v_57, &__v_118) } else { bytes2_xor_value(__v_57, __v_118, record) };
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_60, &__v_121) } else { bytes2_add_value(__v_60, __v_121, record) };
+    let __v_124: G = __b2_add.0;
+    let __v_125: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_64, &__v_122) } else { bytes2_add_value(__v_64, __v_122, record) };
+    let __v_126: G = __b2_add.0;
+    let __v_127: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_126, &__v_125) } else { bytes2_add_value(__v_126, __v_125, record) };
+    let __v_128: G = __b2_add.0;
+    let __v_129: G = __b2_add.1;
+    let __v_130: G = (__v_127 + __v_129);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_69, &__v_123) } else { bytes2_add_value(__v_69, __v_123, record) };
+    let __v_131: G = __b2_add.0;
+    let __v_132: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_131, &__v_130) } else { bytes2_add_value(__v_131, __v_130, record) };
+    let __v_133: G = __b2_add.0;
+    let __v_134: G = __b2_add.1;
+    let __v_135: G = (__v_132 + __v_134);
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_74, &__v_120) } else { bytes2_add_value(__v_74, __v_120, record) };
+    let __v_136: G = __b2_add.0;
+    let __v_137: G = __b2_add.1;
+    let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_136, &__v_135) } else { bytes2_add_value(__v_136, __v_135, record) };
+    let __v_138: G = __b2_add.0;
+    let __v_139: G = __b2_add.1;
+    let __v_140: G = if unconstrained { Bytes2::xor(&__v_80, &__v_124) } else { bytes2_xor_value(__v_80, __v_124, record) };
+    let __v_141: G = if unconstrained { Bytes2::xor(&__v_86, &__v_128) } else { bytes2_xor_value(__v_86, __v_128, record) };
+    let __v_142: G = if unconstrained { Bytes2::xor(&__v_83, &__v_133) } else { bytes2_xor_value(__v_83, __v_133, record) };
+    let __v_143: G = if unconstrained { Bytes2::xor(&__v_87, &__v_138) } else { bytes2_xor_value(__v_87, __v_138, record) };
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_140, &__v_141) } else { bytes2_chain_rotr7_value(__v_140, __v_141, record) };
+    let __v_144: G = __b2_out.0;
+    let __v_145: G = __b2_out.1;
+    let __v_146: G = __b2_out.2;
+    let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_142, &__v_143) } else { bytes2_chain_rotr7_value(__v_142, __v_143, record) };
+    let __v_147: G = __b2_out.0;
+    let __v_148: G = __b2_out.1;
+    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_70] = [__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[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_71: usize = 128;
+const IN_71: usize = 128;
+const OUT_71: usize = 128;
+fn aiur_fn_71(
+  inp: [G; IN_71],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_71], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = inp[106];
+    let __v_107: G = inp[107];
+    let __v_108: G = inp[108];
+    let __v_109: G = inp[109];
+    let __v_110: G = inp[110];
+    let __v_111: G = inp[111];
+    let __v_112: G = inp[112];
+    let __v_113: G = inp[113];
+    let __v_114: G = inp[114];
+    let __v_115: G = inp[115];
+    let __v_116: G = inp[116];
+    let __v_117: G = inp[117];
+    let __v_118: G = inp[118];
+    let __v_119: G = inp[119];
+    let __v_120: G = inp[120];
+    let __v_121: G = inp[121];
+    let __v_122: G = inp[122];
+    let __v_123: G = inp[123];
+    let __v_124: G = inp[124];
+    let __v_125: G = inp[125];
+    let __v_126: G = inp[126];
+    let __v_127: G = inp[127];
+    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__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[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_128: G = __r_arr[0];
+    let __v_129: G = __r_arr[1];
+    let __v_130: G = __r_arr[2];
+    let __v_131: G = __r_arr[3];
+    let __v_132: G = __r_arr[4];
+    let __v_133: G = __r_arr[5];
+    let __v_134: G = __r_arr[6];
+    let __v_135: G = __r_arr[7];
+    let __v_136: G = __r_arr[8];
+    let __v_137: G = __r_arr[9];
+    let __v_138: G = __r_arr[10];
+    let __v_139: G = __r_arr[11];
+    let __v_140: G = __r_arr[12];
+    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_70] = { let __args: [G; IN_70] = [__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[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_144: G = __r_arr[0];
+    let __v_145: G = __r_arr[1];
+    let __v_146: G = __r_arr[2];
+    let __v_147: G = __r_arr[3];
+    let __v_148: G = __r_arr[4];
+    let __v_149: G = __r_arr[5];
+    let __v_150: G = __r_arr[6];
+    let __v_151: G = __r_arr[7];
+    let __v_152: G = __r_arr[8];
+    let __v_153: G = __r_arr[9];
+    let __v_154: G = __r_arr[10];
+    let __v_155: G = __r_arr[11];
+    let __v_156: G = __r_arr[12];
+    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_70] = { let __args: [G; IN_70] = [__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[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_160: G = __r_arr[0];
+    let __v_161: G = __r_arr[1];
+    let __v_162: G = __r_arr[2];
+    let __v_163: G = __r_arr[3];
+    let __v_164: G = __r_arr[4];
+    let __v_165: G = __r_arr[5];
+    let __v_166: G = __r_arr[6];
+    let __v_167: G = __r_arr[7];
+    let __v_168: G = __r_arr[8];
+    let __v_169: G = __r_arr[9];
+    let __v_170: G = __r_arr[10];
+    let __v_171: G = __r_arr[11];
+    let __v_172: G = __r_arr[12];
+    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_70] = { let __args: [G; IN_70] = [__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[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_176: G = __r_arr[0];
+    let __v_177: G = __r_arr[1];
+    let __v_178: G = __r_arr[2];
+    let __v_179: G = __r_arr[3];
+    let __v_180: G = __r_arr[4];
+    let __v_181: G = __r_arr[5];
+    let __v_182: G = __r_arr[6];
+    let __v_183: G = __r_arr[7];
+    let __v_184: G = __r_arr[8];
+    let __v_185: G = __r_arr[9];
+    let __v_186: G = __r_arr[10];
+    let __v_187: G = __r_arr[11];
+    let __v_188: G = __r_arr[12];
+    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_70] = { let __args: [G; IN_70] = [__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[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_192: G = __r_arr[0];
+    let __v_193: G = __r_arr[1];
+    let __v_194: G = __r_arr[2];
+    let __v_195: G = __r_arr[3];
+    let __v_196: G = __r_arr[4];
+    let __v_197: G = __r_arr[5];
+    let __v_198: G = __r_arr[6];
+    let __v_199: G = __r_arr[7];
+    let __v_200: G = __r_arr[8];
+    let __v_201: G = __r_arr[9];
+    let __v_202: G = __r_arr[10];
+    let __v_203: G = __r_arr[11];
+    let __v_204: G = __r_arr[12];
+    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_70] = { let __args: [G; IN_70] = [__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[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_208: G = __r_arr[0];
+    let __v_209: G = __r_arr[1];
+    let __v_210: G = __r_arr[2];
+    let __v_211: G = __r_arr[3];
+    let __v_212: G = __r_arr[4];
+    let __v_213: G = __r_arr[5];
+    let __v_214: G = __r_arr[6];
+    let __v_215: G = __r_arr[7];
+    let __v_216: G = __r_arr[8];
+    let __v_217: G = __r_arr[9];
+    let __v_218: G = __r_arr[10];
+    let __v_219: G = __r_arr[11];
+    let __v_220: G = __r_arr[12];
+    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_70] = { let __args: [G; IN_70] = [__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[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_224: G = __r_arr[0];
+    let __v_225: G = __r_arr[1];
+    let __v_226: G = __r_arr[2];
+    let __v_227: G = __r_arr[3];
+    let __v_228: G = __r_arr[4];
+    let __v_229: G = __r_arr[5];
+    let __v_230: G = __r_arr[6];
+    let __v_231: G = __r_arr[7];
+    let __v_232: G = __r_arr[8];
+    let __v_233: G = __r_arr[9];
+    let __v_234: G = __r_arr[10];
+    let __v_235: G = __r_arr[11];
+    let __v_236: G = __r_arr[12];
+    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_70] = { let __args: [G; IN_70] = [__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[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_240: G = __r_arr[0];
+    let __v_241: G = __r_arr[1];
+    let __v_242: G = __r_arr[2];
+    let __v_243: G = __r_arr[3];
+    let __v_244: G = __r_arr[4];
+    let __v_245: G = __r_arr[5];
+    let __v_246: G = __r_arr[6];
+    let __v_247: G = __r_arr[7];
+    let __v_248: G = __r_arr[8];
+    let __v_249: G = __r_arr[9];
+    let __v_250: G = __r_arr[10];
+    let __v_251: G = __r_arr[11];
+    let __v_252: G = __r_arr[12];
+    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_71] = [__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[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_72: usize = 106;
+const IN_72: usize = 106;
+const OUT_72: usize = 32;
+fn aiur_fn_72(
+  inp: [G; IN_72],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_72], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = G::from_u64(103);
+    let __v_107: G = G::from_u64(230);
+    let __v_108: G = G::from_u64(9);
+    let __v_109: G = G::from_u64(106);
+    let __v_110: G = G::from_u64(133);
+    let __v_111: G = G::from_u64(174);
+    let __v_112: G = G::from_u64(103);
+    let __v_113: G = G::from_u64(187);
+    let __v_114: G = G::from_u64(114);
+    let __v_115: G = G::from_u64(243);
+    let __v_116: G = G::from_u64(110);
+    let __v_117: G = G::from_u64(60);
+    let __v_118: G = G::from_u64(58);
+    let __v_119: G = G::from_u64(245);
+    let __v_120: G = G::from_u64(79);
+    let __v_121: G = G::from_u64(165);
+    let __v_122: G = G::from_u64(0);
+    let __v_123: G = G::from_u64(0);
+    let __v_124: G = G::from_u64(0);
+    let __v_125: G = G::from_u64(0);
+    let __v_126: G = G::from_u64(0);
+    let __v_127: G = G::from_u64(0);
+    let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__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[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_128: G = __r_arr[0];
+    let __v_129: G = __r_arr[1];
+    let __v_130: G = __r_arr[2];
+    let __v_131: G = __r_arr[3];
+    let __v_132: G = __r_arr[4];
+    let __v_133: G = __r_arr[5];
+    let __v_134: G = __r_arr[6];
+    let __v_135: G = __r_arr[7];
+    let __v_136: G = __r_arr[8];
+    let __v_137: G = __r_arr[9];
+    let __v_138: G = __r_arr[10];
+    let __v_139: G = __r_arr[11];
+    let __v_140: G = __r_arr[12];
+    let __v_141: G = __r_arr[13];
+    let __v_142: G = __r_arr[14];
+    let __v_143: G = __r_arr[15];
+    let __v_144: G = __r_arr[16];
+    let __v_145: G = __r_arr[17];
+    let __v_146: G = __r_arr[18];
+    let __v_147: G = __r_arr[19];
+    let __v_148: G = __r_arr[20];
+    let __v_149: G = __r_arr[21];
+    let __v_150: G = __r_arr[22];
+    let __v_151: G = __r_arr[23];
+    let __v_152: G = __r_arr[24];
+    let __v_153: G = __r_arr[25];
+    let __v_154: G = __r_arr[26];
+    let __v_155: G = __r_arr[27];
+    let __v_156: G = __r_arr[28];
+    let __v_157: G = __r_arr[29];
+    let __v_158: G = __r_arr[30];
+    let __v_159: G = __r_arr[31];
+    let __v_160: G = __r_arr[32];
+    let __v_161: G = __r_arr[33];
+    let __v_162: G = __r_arr[34];
+    let __v_163: G = __r_arr[35];
+    let __v_164: G = __r_arr[36];
+    let __v_165: G = __r_arr[37];
+    let __v_166: G = __r_arr[38];
+    let __v_167: G = __r_arr[39];
+    let __v_168: G = __r_arr[40];
+    let __v_169: G = __r_arr[41];
+    let __v_170: G = __r_arr[42];
+    let __v_171: G = __r_arr[43];
+    let __v_172: G = __r_arr[44];
+    let __v_173: G = __r_arr[45];
+    let __v_174: G = __r_arr[46];
+    let __v_175: G = __r_arr[47];
+    let __v_176: G = __r_arr[48];
+    let __v_177: G = __r_arr[49];
+    let __v_178: G = __r_arr[50];
+    let __v_179: G = __r_arr[51];
+    let __v_180: G = __r_arr[52];
+    let __v_181: G = __r_arr[53];
+    let __v_182: G = __r_arr[54];
+    let __v_183: G = __r_arr[55];
+    let __v_184: G = __r_arr[56];
+    let __v_185: G = __r_arr[57];
+    let __v_186: G = __r_arr[58];
+    let __v_187: G = __r_arr[59];
+    let __v_188: G = __r_arr[60];
+    let __v_189: G = __r_arr[61];
+    let __v_190: G = __r_arr[62];
+    let __v_191: G = __r_arr[63];
+    let __v_192: G = __r_arr[64];
+    let __v_193: G = __r_arr[65];
+    let __v_194: G = __r_arr[66];
+    let __v_195: G = __r_arr[67];
+    let __v_196: G = __r_arr[68];
+    let __v_197: G = __r_arr[69];
+    let __v_198: G = __r_arr[70];
+    let __v_199: G = __r_arr[71];
+    let __v_200: G = __r_arr[72];
+    let __v_201: G = __r_arr[73];
+    let __v_202: G = __r_arr[74];
+    let __v_203: G = __r_arr[75];
+    let __v_204: G = __r_arr[76];
+    let __v_205: G = __r_arr[77];
+    let __v_206: G = __r_arr[78];
+    let __v_207: G = __r_arr[79];
+    let __v_208: G = __r_arr[80];
+    let __v_209: G = __r_arr[81];
+    let __v_210: G = __r_arr[82];
+    let __v_211: G = __r_arr[83];
+    let __v_212: G = __r_arr[84];
+    let __v_213: G = __r_arr[85];
+    let __v_214: G = __r_arr[86];
+    let __v_215: G = __r_arr[87];
+    let __v_216: G = __r_arr[88];
+    let __v_217: G = __r_arr[89];
+    let __v_218: G = __r_arr[90];
+    let __v_219: G = __r_arr[91];
+    let __v_220: G = __r_arr[92];
+    let __v_221: G = __r_arr[93];
+    let __v_222: G = __r_arr[94];
+    let __v_223: G = __r_arr[95];
+    let __v_224: G = __r_arr[96];
+    let __v_225: G = __r_arr[97];
+    let __v_226: G = __r_arr[98];
+    let __v_227: G = __r_arr[99];
+    let __v_228: G = __r_arr[100];
+    let __v_229: G = __r_arr[101];
+    let __v_230: G = __r_arr[102];
+    let __v_231: G = __r_arr[103];
+    let __v_232: G = __r_arr[104];
+    let __v_233: G = __r_arr[105];
+    let __v_234: G = __r_arr[106];
+    let __v_235: G = __r_arr[107];
+    let __v_236: G = __r_arr[108];
+    let __v_237: G = __r_arr[109];
+    let __v_238: G = __r_arr[110];
+    let __v_239: G = __r_arr[111];
+    let __v_240: G = __r_arr[112];
+    let __v_241: G = __r_arr[113];
+    let __v_242: G = __r_arr[114];
+    let __v_243: G = __r_arr[115];
+    let __v_244: G = __r_arr[116];
+    let __v_245: G = __r_arr[117];
+    let __v_246: G = __r_arr[118];
+    let __v_247: G = __r_arr[119];
+    let __v_248: G = __r_arr[120];
+    let __v_249: G = __r_arr[121];
+    let __v_250: G = __r_arr[122];
+    let __v_251: G = __r_arr[123];
+    let __v_252: G = __r_arr[124];
+    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_71] = { let __args: [G; IN_71] = [__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[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_256: G = __r_arr[0];
+    let __v_257: G = __r_arr[1];
+    let __v_258: G = __r_arr[2];
+    let __v_259: G = __r_arr[3];
+    let __v_260: G = __r_arr[4];
+    let __v_261: G = __r_arr[5];
+    let __v_262: G = __r_arr[6];
+    let __v_263: G = __r_arr[7];
+    let __v_264: G = __r_arr[8];
+    let __v_265: G = __r_arr[9];
+    let __v_266: G = __r_arr[10];
+    let __v_267: G = __r_arr[11];
+    let __v_268: G = __r_arr[12];
+    let __v_269: G = __r_arr[13];
+    let __v_270: G = __r_arr[14];
+    let __v_271: G = __r_arr[15];
+    let __v_272: G = __r_arr[16];
+    let __v_273: G = __r_arr[17];
+    let __v_274: G = __r_arr[18];
+    let __v_275: G = __r_arr[19];
+    let __v_276: G = __r_arr[20];
+    let __v_277: G = __r_arr[21];
+    let __v_278: G = __r_arr[22];
+    let __v_279: G = __r_arr[23];
+    let __v_280: G = __r_arr[24];
+    let __v_281: G = __r_arr[25];
+    let __v_282: G = __r_arr[26];
+    let __v_283: G = __r_arr[27];
+    let __v_284: G = __r_arr[28];
+    let __v_285: G = __r_arr[29];
+    let __v_286: G = __r_arr[30];
+    let __v_287: G = __r_arr[31];
+    let __v_288: G = __r_arr[32];
+    let __v_289: G = __r_arr[33];
+    let __v_290: G = __r_arr[34];
+    let __v_291: G = __r_arr[35];
+    let __v_292: G = __r_arr[36];
+    let __v_293: G = __r_arr[37];
+    let __v_294: G = __r_arr[38];
+    let __v_295: G = __r_arr[39];
+    let __v_296: G = __r_arr[40];
+    let __v_297: G = __r_arr[41];
+    let __v_298: G = __r_arr[42];
+    let __v_299: G = __r_arr[43];
+    let __v_300: G = __r_arr[44];
+    let __v_301: G = __r_arr[45];
+    let __v_302: G = __r_arr[46];
+    let __v_303: G = __r_arr[47];
+    let __v_304: G = __r_arr[48];
+    let __v_305: G = __r_arr[49];
+    let __v_306: G = __r_arr[50];
+    let __v_307: G = __r_arr[51];
+    let __v_308: G = __r_arr[52];
+    let __v_309: G = __r_arr[53];
+    let __v_310: G = __r_arr[54];
+    let __v_311: G = __r_arr[55];
+    let __v_312: G = __r_arr[56];
+    let __v_313: G = __r_arr[57];
+    let __v_314: G = __r_arr[58];
+    let __v_315: G = __r_arr[59];
+    let __v_316: G = __r_arr[60];
+    let __v_317: G = __r_arr[61];
+    let __v_318: G = __r_arr[62];
+    let __v_319: G = __r_arr[63];
+    let __v_320: G = __r_arr[64];
+    let __v_321: G = __r_arr[65];
+    let __v_322: G = __r_arr[66];
+    let __v_323: G = __r_arr[67];
+    let __v_324: G = __r_arr[68];
+    let __v_325: G = __r_arr[69];
+    let __v_326: G = __r_arr[70];
+    let __v_327: G = __r_arr[71];
+    let __v_328: G = __r_arr[72];
+    let __v_329: G = __r_arr[73];
+    let __v_330: G = __r_arr[74];
+    let __v_331: G = __r_arr[75];
+    let __v_332: G = __r_arr[76];
+    let __v_333: G = __r_arr[77];
+    let __v_334: G = __r_arr[78];
+    let __v_335: G = __r_arr[79];
+    let __v_336: G = __r_arr[80];
+    let __v_337: G = __r_arr[81];
+    let __v_338: G = __r_arr[82];
+    let __v_339: G = __r_arr[83];
+    let __v_340: G = __r_arr[84];
+    let __v_341: G = __r_arr[85];
+    let __v_342: G = __r_arr[86];
+    let __v_343: G = __r_arr[87];
+    let __v_344: G = __r_arr[88];
+    let __v_345: G = __r_arr[89];
+    let __v_346: G = __r_arr[90];
+    let __v_347: G = __r_arr[91];
+    let __v_348: G = __r_arr[92];
+    let __v_349: G = __r_arr[93];
+    let __v_350: G = __r_arr[94];
+    let __v_351: G = __r_arr[95];
+    let __v_352: G = __r_arr[96];
+    let __v_353: G = __r_arr[97];
+    let __v_354: G = __r_arr[98];
+    let __v_355: G = __r_arr[99];
+    let __v_356: G = __r_arr[100];
+    let __v_357: G = __r_arr[101];
+    let __v_358: G = __r_arr[102];
+    let __v_359: G = __r_arr[103];
+    let __v_360: G = __r_arr[104];
+    let __v_361: G = __r_arr[105];
+    let __v_362: G = __r_arr[106];
+    let __v_363: G = __r_arr[107];
+    let __v_364: G = __r_arr[108];
+    let __v_365: G = __r_arr[109];
+    let __v_366: G = __r_arr[110];
+    let __v_367: G = __r_arr[111];
+    let __v_368: G = __r_arr[112];
+    let __v_369: G = __r_arr[113];
+    let __v_370: G = __r_arr[114];
+    let __v_371: G = __r_arr[115];
+    let __v_372: G = __r_arr[116];
+    let __v_373: G = __r_arr[117];
+    let __v_374: G = __r_arr[118];
+    let __v_375: G = __r_arr[119];
+    let __v_376: G = __r_arr[120];
+    let __v_377: G = __r_arr[121];
+    let __v_378: G = __r_arr[122];
+    let __v_379: G = __r_arr[123];
+    let __v_380: G = __r_arr[124];
+    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_71] = { let __args: [G; IN_71] = [__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[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_384: G = __r_arr[0];
+    let __v_385: G = __r_arr[1];
+    let __v_386: G = __r_arr[2];
+    let __v_387: G = __r_arr[3];
+    let __v_388: G = __r_arr[4];
+    let __v_389: G = __r_arr[5];
+    let __v_390: G = __r_arr[6];
+    let __v_391: G = __r_arr[7];
+    let __v_392: G = __r_arr[8];
+    let __v_393: G = __r_arr[9];
+    let __v_394: G = __r_arr[10];
+    let __v_395: G = __r_arr[11];
+    let __v_396: G = __r_arr[12];
+    let __v_397: G = __r_arr[13];
+    let __v_398: G = __r_arr[14];
+    let __v_399: G = __r_arr[15];
+    let __v_400: G = __r_arr[16];
+    let __v_401: G = __r_arr[17];
+    let __v_402: G = __r_arr[18];
+    let __v_403: G = __r_arr[19];
+    let __v_404: G = __r_arr[20];
+    let __v_405: G = __r_arr[21];
+    let __v_406: G = __r_arr[22];
+    let __v_407: G = __r_arr[23];
+    let __v_408: G = __r_arr[24];
+    let __v_409: G = __r_arr[25];
+    let __v_410: G = __r_arr[26];
+    let __v_411: G = __r_arr[27];
+    let __v_412: G = __r_arr[28];
+    let __v_413: G = __r_arr[29];
+    let __v_414: G = __r_arr[30];
+    let __v_415: G = __r_arr[31];
+    let __v_416: G = __r_arr[32];
+    let __v_417: G = __r_arr[33];
+    let __v_418: G = __r_arr[34];
+    let __v_419: G = __r_arr[35];
+    let __v_420: G = __r_arr[36];
+    let __v_421: G = __r_arr[37];
+    let __v_422: G = __r_arr[38];
+    let __v_423: G = __r_arr[39];
+    let __v_424: G = __r_arr[40];
+    let __v_425: G = __r_arr[41];
+    let __v_426: G = __r_arr[42];
+    let __v_427: G = __r_arr[43];
+    let __v_428: G = __r_arr[44];
+    let __v_429: G = __r_arr[45];
+    let __v_430: G = __r_arr[46];
+    let __v_431: G = __r_arr[47];
+    let __v_432: G = __r_arr[48];
+    let __v_433: G = __r_arr[49];
+    let __v_434: G = __r_arr[50];
+    let __v_435: G = __r_arr[51];
+    let __v_436: G = __r_arr[52];
+    let __v_437: G = __r_arr[53];
+    let __v_438: G = __r_arr[54];
+    let __v_439: G = __r_arr[55];
+    let __v_440: G = __r_arr[56];
+    let __v_441: G = __r_arr[57];
+    let __v_442: G = __r_arr[58];
+    let __v_443: G = __r_arr[59];
+    let __v_444: G = __r_arr[60];
+    let __v_445: G = __r_arr[61];
+    let __v_446: G = __r_arr[62];
+    let __v_447: G = __r_arr[63];
+    let __v_448: G = __r_arr[64];
+    let __v_449: G = __r_arr[65];
+    let __v_450: G = __r_arr[66];
+    let __v_451: G = __r_arr[67];
+    let __v_452: G = __r_arr[68];
+    let __v_453: G = __r_arr[69];
+    let __v_454: G = __r_arr[70];
+    let __v_455: G = __r_arr[71];
+    let __v_456: G = __r_arr[72];
+    let __v_457: G = __r_arr[73];
+    let __v_458: G = __r_arr[74];
+    let __v_459: G = __r_arr[75];
+    let __v_460: G = __r_arr[76];
+    let __v_461: G = __r_arr[77];
+    let __v_462: G = __r_arr[78];
+    let __v_463: G = __r_arr[79];
+    let __v_464: G = __r_arr[80];
+    let __v_465: G = __r_arr[81];
+    let __v_466: G = __r_arr[82];
+    let __v_467: G = __r_arr[83];
+    let __v_468: G = __r_arr[84];
+    let __v_469: G = __r_arr[85];
+    let __v_470: G = __r_arr[86];
+    let __v_471: G = __r_arr[87];
+    let __v_472: G = __r_arr[88];
+    let __v_473: G = __r_arr[89];
+    let __v_474: G = __r_arr[90];
+    let __v_475: G = __r_arr[91];
+    let __v_476: G = __r_arr[92];
+    let __v_477: G = __r_arr[93];
+    let __v_478: G = __r_arr[94];
+    let __v_479: G = __r_arr[95];
+    let __v_480: G = __r_arr[96];
+    let __v_481: G = __r_arr[97];
+    let __v_482: G = __r_arr[98];
+    let __v_483: G = __r_arr[99];
+    let __v_484: G = __r_arr[100];
+    let __v_485: G = __r_arr[101];
+    let __v_486: G = __r_arr[102];
+    let __v_487: G = __r_arr[103];
+    let __v_488: G = __r_arr[104];
+    let __v_489: G = __r_arr[105];
+    let __v_490: G = __r_arr[106];
+    let __v_491: G = __r_arr[107];
+    let __v_492: G = __r_arr[108];
+    let __v_493: G = __r_arr[109];
+    let __v_494: G = __r_arr[110];
+    let __v_495: G = __r_arr[111];
+    let __v_496: G = __r_arr[112];
+    let __v_497: G = __r_arr[113];
+    let __v_498: G = __r_arr[114];
+    let __v_499: G = __r_arr[115];
+    let __v_500: G = __r_arr[116];
+    let __v_501: G = __r_arr[117];
+    let __v_502: G = __r_arr[118];
+    let __v_503: G = __r_arr[119];
+    let __v_504: G = __r_arr[120];
+    let __v_505: G = __r_arr[121];
+    let __v_506: G = __r_arr[122];
+    let __v_507: G = __r_arr[123];
+    let __v_508: G = __r_arr[124];
+    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_71] = { let __args: [G; IN_71] = [__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[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_512: G = __r_arr[0];
+    let __v_513: G = __r_arr[1];
+    let __v_514: G = __r_arr[2];
+    let __v_515: G = __r_arr[3];
+    let __v_516: G = __r_arr[4];
+    let __v_517: G = __r_arr[5];
+    let __v_518: G = __r_arr[6];
+    let __v_519: G = __r_arr[7];
+    let __v_520: G = __r_arr[8];
+    let __v_521: G = __r_arr[9];
+    let __v_522: G = __r_arr[10];
+    let __v_523: G = __r_arr[11];
+    let __v_524: G = __r_arr[12];
+    let __v_525: G = __r_arr[13];
+    let __v_526: G = __r_arr[14];
+    let __v_527: G = __r_arr[15];
+    let __v_528: G = __r_arr[16];
+    let __v_529: G = __r_arr[17];
+    let __v_530: G = __r_arr[18];
+    let __v_531: G = __r_arr[19];
+    let __v_532: G = __r_arr[20];
+    let __v_533: G = __r_arr[21];
+    let __v_534: G = __r_arr[22];
+    let __v_535: G = __r_arr[23];
+    let __v_536: G = __r_arr[24];
+    let __v_537: G = __r_arr[25];
+    let __v_538: G = __r_arr[26];
+    let __v_539: G = __r_arr[27];
+    let __v_540: G = __r_arr[28];
+    let __v_541: G = __r_arr[29];
+    let __v_542: G = __r_arr[30];
+    let __v_543: G = __r_arr[31];
+    let __v_544: G = __r_arr[32];
+    let __v_545: G = __r_arr[33];
+    let __v_546: G = __r_arr[34];
+    let __v_547: G = __r_arr[35];
+    let __v_548: G = __r_arr[36];
+    let __v_549: G = __r_arr[37];
+    let __v_550: G = __r_arr[38];
+    let __v_551: G = __r_arr[39];
+    let __v_552: G = __r_arr[40];
+    let __v_553: G = __r_arr[41];
+    let __v_554: G = __r_arr[42];
+    let __v_555: G = __r_arr[43];
+    let __v_556: G = __r_arr[44];
+    let __v_557: G = __r_arr[45];
+    let __v_558: G = __r_arr[46];
+    let __v_559: G = __r_arr[47];
+    let __v_560: G = __r_arr[48];
+    let __v_561: G = __r_arr[49];
+    let __v_562: G = __r_arr[50];
+    let __v_563: G = __r_arr[51];
+    let __v_564: G = __r_arr[52];
+    let __v_565: G = __r_arr[53];
+    let __v_566: G = __r_arr[54];
+    let __v_567: G = __r_arr[55];
+    let __v_568: G = __r_arr[56];
+    let __v_569: G = __r_arr[57];
+    let __v_570: G = __r_arr[58];
+    let __v_571: G = __r_arr[59];
+    let __v_572: G = __r_arr[60];
+    let __v_573: G = __r_arr[61];
+    let __v_574: G = __r_arr[62];
+    let __v_575: G = __r_arr[63];
+    let __v_576: G = __r_arr[64];
+    let __v_577: G = __r_arr[65];
+    let __v_578: G = __r_arr[66];
+    let __v_579: G = __r_arr[67];
+    let __v_580: G = __r_arr[68];
+    let __v_581: G = __r_arr[69];
+    let __v_582: G = __r_arr[70];
+    let __v_583: G = __r_arr[71];
+    let __v_584: G = __r_arr[72];
+    let __v_585: G = __r_arr[73];
+    let __v_586: G = __r_arr[74];
+    let __v_587: G = __r_arr[75];
+    let __v_588: G = __r_arr[76];
+    let __v_589: G = __r_arr[77];
+    let __v_590: G = __r_arr[78];
+    let __v_591: G = __r_arr[79];
+    let __v_592: G = __r_arr[80];
+    let __v_593: G = __r_arr[81];
+    let __v_594: G = __r_arr[82];
+    let __v_595: G = __r_arr[83];
+    let __v_596: G = __r_arr[84];
+    let __v_597: G = __r_arr[85];
+    let __v_598: G = __r_arr[86];
+    let __v_599: G = __r_arr[87];
+    let __v_600: G = __r_arr[88];
+    let __v_601: G = __r_arr[89];
+    let __v_602: G = __r_arr[90];
+    let __v_603: G = __r_arr[91];
+    let __v_604: G = __r_arr[92];
+    let __v_605: G = __r_arr[93];
+    let __v_606: G = __r_arr[94];
+    let __v_607: G = __r_arr[95];
+    let __v_608: G = __r_arr[96];
+    let __v_609: G = __r_arr[97];
+    let __v_610: G = __r_arr[98];
+    let __v_611: G = __r_arr[99];
+    let __v_612: G = __r_arr[100];
+    let __v_613: G = __r_arr[101];
+    let __v_614: G = __r_arr[102];
+    let __v_615: G = __r_arr[103];
+    let __v_616: G = __r_arr[104];
+    let __v_617: G = __r_arr[105];
+    let __v_618: G = __r_arr[106];
+    let __v_619: G = __r_arr[107];
+    let __v_620: G = __r_arr[108];
+    let __v_621: G = __r_arr[109];
+    let __v_622: G = __r_arr[110];
+    let __v_623: G = __r_arr[111];
+    let __v_624: G = __r_arr[112];
+    let __v_625: G = __r_arr[113];
+    let __v_626: G = __r_arr[114];
+    let __v_627: G = __r_arr[115];
+    let __v_628: G = __r_arr[116];
+    let __v_629: G = __r_arr[117];
+    let __v_630: G = __r_arr[118];
+    let __v_631: G = __r_arr[119];
+    let __v_632: G = __r_arr[120];
+    let __v_633: G = __r_arr[121];
+    let __v_634: G = __r_arr[122];
+    let __v_635: G = __r_arr[123];
+    let __v_636: G = __r_arr[124];
+    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_71] = { let __args: [G; IN_71] = [__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[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_640: G = __r_arr[0];
+    let __v_641: G = __r_arr[1];
+    let __v_642: G = __r_arr[2];
+    let __v_643: G = __r_arr[3];
+    let __v_644: G = __r_arr[4];
+    let __v_645: G = __r_arr[5];
+    let __v_646: G = __r_arr[6];
+    let __v_647: G = __r_arr[7];
+    let __v_648: G = __r_arr[8];
+    let __v_649: G = __r_arr[9];
+    let __v_650: G = __r_arr[10];
+    let __v_651: G = __r_arr[11];
+    let __v_652: G = __r_arr[12];
+    let __v_653: G = __r_arr[13];
+    let __v_654: G = __r_arr[14];
+    let __v_655: G = __r_arr[15];
+    let __v_656: G = __r_arr[16];
+    let __v_657: G = __r_arr[17];
+    let __v_658: G = __r_arr[18];
+    let __v_659: G = __r_arr[19];
+    let __v_660: G = __r_arr[20];
+    let __v_661: G = __r_arr[21];
+    let __v_662: G = __r_arr[22];
+    let __v_663: G = __r_arr[23];
+    let __v_664: G = __r_arr[24];
+    let __v_665: G = __r_arr[25];
+    let __v_666: G = __r_arr[26];
+    let __v_667: G = __r_arr[27];
+    let __v_668: G = __r_arr[28];
+    let __v_669: G = __r_arr[29];
+    let __v_670: G = __r_arr[30];
+    let __v_671: G = __r_arr[31];
+    let __v_672: G = __r_arr[32];
+    let __v_673: G = __r_arr[33];
+    let __v_674: G = __r_arr[34];
+    let __v_675: G = __r_arr[35];
+    let __v_676: G = __r_arr[36];
+    let __v_677: G = __r_arr[37];
+    let __v_678: G = __r_arr[38];
+    let __v_679: G = __r_arr[39];
+    let __v_680: G = __r_arr[40];
+    let __v_681: G = __r_arr[41];
+    let __v_682: G = __r_arr[42];
+    let __v_683: G = __r_arr[43];
+    let __v_684: G = __r_arr[44];
+    let __v_685: G = __r_arr[45];
+    let __v_686: G = __r_arr[46];
+    let __v_687: G = __r_arr[47];
+    let __v_688: G = __r_arr[48];
+    let __v_689: G = __r_arr[49];
+    let __v_690: G = __r_arr[50];
+    let __v_691: G = __r_arr[51];
+    let __v_692: G = __r_arr[52];
+    let __v_693: G = __r_arr[53];
+    let __v_694: G = __r_arr[54];
+    let __v_695: G = __r_arr[55];
+    let __v_696: G = __r_arr[56];
+    let __v_697: G = __r_arr[57];
+    let __v_698: G = __r_arr[58];
+    let __v_699: G = __r_arr[59];
+    let __v_700: G = __r_arr[60];
+    let __v_701: G = __r_arr[61];
+    let __v_702: G = __r_arr[62];
+    let __v_703: G = __r_arr[63];
+    let __v_704: G = __r_arr[64];
+    let __v_705: G = __r_arr[65];
+    let __v_706: G = __r_arr[66];
+    let __v_707: G = __r_arr[67];
+    let __v_708: G = __r_arr[68];
+    let __v_709: G = __r_arr[69];
+    let __v_710: G = __r_arr[70];
+    let __v_711: G = __r_arr[71];
+    let __v_712: G = __r_arr[72];
+    let __v_713: G = __r_arr[73];
+    let __v_714: G = __r_arr[74];
+    let __v_715: G = __r_arr[75];
+    let __v_716: G = __r_arr[76];
+    let __v_717: G = __r_arr[77];
+    let __v_718: G = __r_arr[78];
+    let __v_719: G = __r_arr[79];
+    let __v_720: G = __r_arr[80];
+    let __v_721: G = __r_arr[81];
+    let __v_722: G = __r_arr[82];
+    let __v_723: G = __r_arr[83];
+    let __v_724: G = __r_arr[84];
+    let __v_725: G = __r_arr[85];
+    let __v_726: G = __r_arr[86];
+    let __v_727: G = __r_arr[87];
+    let __v_728: G = __r_arr[88];
+    let __v_729: G = __r_arr[89];
+    let __v_730: G = __r_arr[90];
+    let __v_731: G = __r_arr[91];
+    let __v_732: G = __r_arr[92];
+    let __v_733: G = __r_arr[93];
+    let __v_734: G = __r_arr[94];
+    let __v_735: G = __r_arr[95];
+    let __v_736: G = __r_arr[96];
+    let __v_737: G = __r_arr[97];
+    let __v_738: G = __r_arr[98];
+    let __v_739: G = __r_arr[99];
+    let __v_740: G = __r_arr[100];
+    let __v_741: G = __r_arr[101];
+    let __v_742: G = __r_arr[102];
+    let __v_743: G = __r_arr[103];
+    let __v_744: G = __r_arr[104];
+    let __v_745: G = __r_arr[105];
+    let __v_746: G = __r_arr[106];
+    let __v_747: G = __r_arr[107];
+    let __v_748: G = __r_arr[108];
+    let __v_749: G = __r_arr[109];
+    let __v_750: G = __r_arr[110];
+    let __v_751: G = __r_arr[111];
+    let __v_752: G = __r_arr[112];
+    let __v_753: G = __r_arr[113];
+    let __v_754: G = __r_arr[114];
+    let __v_755: G = __r_arr[115];
+    let __v_756: G = __r_arr[116];
+    let __v_757: G = __r_arr[117];
+    let __v_758: G = __r_arr[118];
+    let __v_759: G = __r_arr[119];
+    let __v_760: G = __r_arr[120];
+    let __v_761: G = __r_arr[121];
+    let __v_762: G = __r_arr[122];
+    let __v_763: G = __r_arr[123];
+    let __v_764: G = __r_arr[124];
+    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_71] = { let __args: [G; IN_71] = [__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[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_768: G = __r_arr[0];
+    let __v_769: G = __r_arr[1];
+    let __v_770: G = __r_arr[2];
+    let __v_771: G = __r_arr[3];
+    let __v_772: G = __r_arr[4];
+    let __v_773: G = __r_arr[5];
+    let __v_774: G = __r_arr[6];
+    let __v_775: G = __r_arr[7];
+    let __v_776: G = __r_arr[8];
+    let __v_777: G = __r_arr[9];
+    let __v_778: G = __r_arr[10];
+    let __v_779: G = __r_arr[11];
+    let __v_780: G = __r_arr[12];
+    let __v_781: G = __r_arr[13];
+    let __v_782: G = __r_arr[14];
+    let __v_783: G = __r_arr[15];
+    let __v_784: G = __r_arr[16];
+    let __v_785: G = __r_arr[17];
+    let __v_786: G = __r_arr[18];
+    let __v_787: G = __r_arr[19];
+    let __v_788: G = __r_arr[20];
+    let __v_789: G = __r_arr[21];
+    let __v_790: G = __r_arr[22];
+    let __v_791: G = __r_arr[23];
+    let __v_792: G = __r_arr[24];
+    let __v_793: G = __r_arr[25];
+    let __v_794: G = __r_arr[26];
+    let __v_795: G = __r_arr[27];
+    let __v_796: G = __r_arr[28];
+    let __v_797: G = __r_arr[29];
+    let __v_798: G = __r_arr[30];
+    let __v_799: G = __r_arr[31];
+    let __v_800: G = __r_arr[32];
+    let __v_801: G = __r_arr[33];
+    let __v_802: G = __r_arr[34];
+    let __v_803: G = __r_arr[35];
+    let __v_804: G = __r_arr[36];
+    let __v_805: G = __r_arr[37];
+    let __v_806: G = __r_arr[38];
+    let __v_807: G = __r_arr[39];
+    let __v_808: G = __r_arr[40];
+    let __v_809: G = __r_arr[41];
+    let __v_810: G = __r_arr[42];
+    let __v_811: G = __r_arr[43];
+    let __v_812: G = __r_arr[44];
+    let __v_813: G = __r_arr[45];
+    let __v_814: G = __r_arr[46];
+    let __v_815: G = __r_arr[47];
+    let __v_816: G = __r_arr[48];
+    let __v_817: G = __r_arr[49];
+    let __v_818: G = __r_arr[50];
+    let __v_819: G = __r_arr[51];
+    let __v_820: G = __r_arr[52];
+    let __v_821: G = __r_arr[53];
+    let __v_822: G = __r_arr[54];
+    let __v_823: G = __r_arr[55];
+    let __v_824: G = __r_arr[56];
+    let __v_825: G = __r_arr[57];
+    let __v_826: G = __r_arr[58];
+    let __v_827: G = __r_arr[59];
+    let __v_828: G = __r_arr[60];
+    let __v_829: G = __r_arr[61];
+    let __v_830: G = __r_arr[62];
+    let __v_831: G = __r_arr[63];
+    let __v_832: G = __r_arr[64];
+    let __v_833: G = __r_arr[65];
+    let __v_834: G = __r_arr[66];
+    let __v_835: G = __r_arr[67];
+    let __v_836: G = __r_arr[68];
+    let __v_837: G = __r_arr[69];
+    let __v_838: G = __r_arr[70];
+    let __v_839: G = __r_arr[71];
+    let __v_840: G = __r_arr[72];
+    let __v_841: G = __r_arr[73];
+    let __v_842: G = __r_arr[74];
+    let __v_843: G = __r_arr[75];
+    let __v_844: G = __r_arr[76];
+    let __v_845: G = __r_arr[77];
+    let __v_846: G = __r_arr[78];
+    let __v_847: G = __r_arr[79];
+    let __v_848: G = __r_arr[80];
+    let __v_849: G = __r_arr[81];
+    let __v_850: G = __r_arr[82];
+    let __v_851: G = __r_arr[83];
+    let __v_852: G = __r_arr[84];
+    let __v_853: G = __r_arr[85];
+    let __v_854: G = __r_arr[86];
+    let __v_855: G = __r_arr[87];
+    let __v_856: G = __r_arr[88];
+    let __v_857: G = __r_arr[89];
+    let __v_858: G = __r_arr[90];
+    let __v_859: G = __r_arr[91];
+    let __v_860: G = __r_arr[92];
+    let __v_861: G = __r_arr[93];
+    let __v_862: G = __r_arr[94];
+    let __v_863: G = __r_arr[95];
+    let __v_864: G = __r_arr[96];
+    let __v_865: G = __r_arr[97];
+    let __v_866: G = __r_arr[98];
+    let __v_867: G = __r_arr[99];
+    let __v_868: G = __r_arr[100];
+    let __v_869: G = __r_arr[101];
+    let __v_870: G = __r_arr[102];
+    let __v_871: G = __r_arr[103];
+    let __v_872: G = __r_arr[104];
+    let __v_873: G = __r_arr[105];
+    let __v_874: G = __r_arr[106];
+    let __v_875: G = __r_arr[107];
+    let __v_876: G = __r_arr[108];
+    let __v_877: G = __r_arr[109];
+    let __v_878: G = __r_arr[110];
+    let __v_879: G = __r_arr[111];
+    let __v_880: G = __r_arr[112];
+    let __v_881: G = __r_arr[113];
+    let __v_882: G = __r_arr[114];
+    let __v_883: G = __r_arr[115];
+    let __v_884: G = __r_arr[116];
+    let __v_885: G = __r_arr[117];
+    let __v_886: G = __r_arr[118];
+    let __v_887: G = __r_arr[119];
+    let __v_888: G = __r_arr[120];
+    let __v_889: G = __r_arr[121];
+    let __v_890: G = __r_arr[122];
+    let __v_891: G = __r_arr[123];
+    let __v_892: G = __r_arr[124];
+    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_71] = { let __args: [G; IN_71] = [__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[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_896: G = __r_arr[0];
+    let __v_897: G = __r_arr[1];
+    let __v_898: G = __r_arr[2];
+    let __v_899: G = __r_arr[3];
+    let __v_900: G = __r_arr[4];
+    let __v_901: G = __r_arr[5];
+    let __v_902: G = __r_arr[6];
+    let __v_903: G = __r_arr[7];
+    let __v_904: G = __r_arr[8];
+    let __v_905: G = __r_arr[9];
+    let __v_906: G = __r_arr[10];
+    let __v_907: G = __r_arr[11];
+    let __v_908: G = __r_arr[12];
+    let __v_909: G = __r_arr[13];
+    let __v_910: G = __r_arr[14];
+    let __v_911: G = __r_arr[15];
+    let __v_912: G = __r_arr[16];
+    let __v_913: G = __r_arr[17];
+    let __v_914: G = __r_arr[18];
+    let __v_915: G = __r_arr[19];
+    let __v_916: G = __r_arr[20];
+    let __v_917: G = __r_arr[21];
+    let __v_918: G = __r_arr[22];
+    let __v_919: G = __r_arr[23];
+    let __v_920: G = __r_arr[24];
+    let __v_921: G = __r_arr[25];
+    let __v_922: G = __r_arr[26];
+    let __v_923: G = __r_arr[27];
+    let __v_924: G = __r_arr[28];
+    let __v_925: G = __r_arr[29];
+    let __v_926: G = __r_arr[30];
+    let __v_927: G = __r_arr[31];
+    let __v_928: G = __r_arr[32];
+    let __v_929: G = __r_arr[33];
+    let __v_930: G = __r_arr[34];
+    let __v_931: G = __r_arr[35];
+    let __v_932: G = __r_arr[36];
+    let __v_933: G = __r_arr[37];
+    let __v_934: G = __r_arr[38];
+    let __v_935: G = __r_arr[39];
+    let __v_936: G = __r_arr[40];
+    let __v_937: G = __r_arr[41];
+    let __v_938: G = __r_arr[42];
+    let __v_939: G = __r_arr[43];
+    let __v_940: G = __r_arr[44];
+    let __v_941: G = __r_arr[45];
+    let __v_942: G = __r_arr[46];
+    let __v_943: G = __r_arr[47];
+    let __v_944: G = __r_arr[48];
+    let __v_945: G = __r_arr[49];
+    let __v_946: G = __r_arr[50];
+    let __v_947: G = __r_arr[51];
+    let __v_948: G = __r_arr[52];
+    let __v_949: G = __r_arr[53];
+    let __v_950: G = __r_arr[54];
+    let __v_951: G = __r_arr[55];
+    let __v_952: G = __r_arr[56];
+    let __v_953: G = __r_arr[57];
+    let __v_954: G = __r_arr[58];
+    let __v_955: G = __r_arr[59];
+    let __v_956: G = __r_arr[60];
+    let __v_957: G = __r_arr[61];
+    let __v_958: G = __r_arr[62];
+    let __v_959: G = __r_arr[63];
+    let __v_960: G = __r_arr[64];
+    let __v_961: G = __r_arr[65];
+    let __v_962: G = __r_arr[66];
+    let __v_963: G = __r_arr[67];
+    let __v_964: G = __r_arr[68];
+    let __v_965: G = __r_arr[69];
+    let __v_966: G = __r_arr[70];
+    let __v_967: G = __r_arr[71];
+    let __v_968: G = __r_arr[72];
+    let __v_969: G = __r_arr[73];
+    let __v_970: G = __r_arr[74];
+    let __v_971: G = __r_arr[75];
+    let __v_972: G = __r_arr[76];
+    let __v_973: G = __r_arr[77];
+    let __v_974: G = __r_arr[78];
+    let __v_975: G = __r_arr[79];
+    let __v_976: G = __r_arr[80];
+    let __v_977: G = __r_arr[81];
+    let __v_978: G = __r_arr[82];
+    let __v_979: G = __r_arr[83];
+    let __v_980: G = __r_arr[84];
+    let __v_981: G = __r_arr[85];
+    let __v_982: G = __r_arr[86];
+    let __v_983: G = __r_arr[87];
+    let __v_984: G = __r_arr[88];
+    let __v_985: G = __r_arr[89];
+    let __v_986: G = __r_arr[90];
+    let __v_987: G = __r_arr[91];
+    let __v_988: G = __r_arr[92];
+    let __v_989: G = __r_arr[93];
+    let __v_990: G = __r_arr[94];
+    let __v_991: G = __r_arr[95];
+    let __v_992: G = __r_arr[96];
+    let __v_993: G = __r_arr[97];
+    let __v_994: G = __r_arr[98];
+    let __v_995: G = __r_arr[99];
+    let __v_996: G = __r_arr[100];
+    let __v_997: G = __r_arr[101];
+    let __v_998: G = __r_arr[102];
+    let __v_999: G = __r_arr[103];
+    let __v_1000: G = __r_arr[104];
+    let __v_1001: G = __r_arr[105];
+    let __v_1002: G = __r_arr[106];
+    let __v_1003: G = __r_arr[107];
+    let __v_1004: G = __r_arr[108];
+    let __v_1005: G = __r_arr[109];
+    let __v_1006: G = __r_arr[110];
+    let __v_1007: G = __r_arr[111];
+    let __v_1008: G = __r_arr[112];
+    let __v_1009: G = __r_arr[113];
+    let __v_1010: G = __r_arr[114];
+    let __v_1011: G = __r_arr[115];
+    let __v_1012: G = __r_arr[116];
+    let __v_1013: G = __r_arr[117];
+    let __v_1014: G = __r_arr[118];
+    let __v_1015: G = __r_arr[119];
+    let __v_1016: G = __r_arr[120];
+    let __v_1017: G = __r_arr[121];
+    let __v_1018: G = __r_arr[122];
+    let __v_1019: G = __r_arr[123];
+    let __v_1020: G = __r_arr[124];
+    let __v_1021: G = __r_arr[125];
+    let __v_1022: G = __r_arr[126];
+    let __v_1023: G = __r_arr[127];
+    let __v_1024: G = if unconstrained { Bytes2::xor(&__v_896, &__v_928) } else { bytes2_xor_value(__v_896, __v_928, record) };
+    let __v_1025: G = if unconstrained { Bytes2::xor(&__v_897, &__v_929) } else { bytes2_xor_value(__v_897, __v_929, record) };
+    let __v_1026: G = if unconstrained { Bytes2::xor(&__v_898, &__v_930) } else { bytes2_xor_value(__v_898, __v_930, record) };
+    let __v_1027: G = if unconstrained { Bytes2::xor(&__v_899, &__v_931) } else { bytes2_xor_value(__v_899, __v_931, record) };
+    let __v_1028: G = if unconstrained { Bytes2::xor(&__v_900, &__v_932) } else { bytes2_xor_value(__v_900, __v_932, record) };
+    let __v_1029: G = if unconstrained { Bytes2::xor(&__v_901, &__v_933) } else { bytes2_xor_value(__v_901, __v_933, record) };
+    let __v_1030: G = if unconstrained { Bytes2::xor(&__v_902, &__v_934) } else { bytes2_xor_value(__v_902, __v_934, record) };
+    let __v_1031: G = if unconstrained { Bytes2::xor(&__v_903, &__v_935) } else { bytes2_xor_value(__v_903, __v_935, record) };
+    let __v_1032: G = if unconstrained { Bytes2::xor(&__v_904, &__v_936) } else { bytes2_xor_value(__v_904, __v_936, record) };
+    let __v_1033: G = if unconstrained { Bytes2::xor(&__v_905, &__v_937) } else { bytes2_xor_value(__v_905, __v_937, record) };
+    let __v_1034: G = if unconstrained { Bytes2::xor(&__v_906, &__v_938) } else { bytes2_xor_value(__v_906, __v_938, record) };
+    let __v_1035: G = if unconstrained { Bytes2::xor(&__v_907, &__v_939) } else { bytes2_xor_value(__v_907, __v_939, record) };
+    let __v_1036: G = if unconstrained { Bytes2::xor(&__v_908, &__v_940) } else { bytes2_xor_value(__v_908, __v_940, record) };
+    let __v_1037: G = if unconstrained { Bytes2::xor(&__v_909, &__v_941) } else { bytes2_xor_value(__v_909, __v_941, record) };
+    let __v_1038: G = if unconstrained { Bytes2::xor(&__v_910, &__v_942) } else { bytes2_xor_value(__v_910, __v_942, record) };
+    let __v_1039: G = if unconstrained { Bytes2::xor(&__v_911, &__v_943) } else { bytes2_xor_value(__v_911, __v_943, record) };
+    let __v_1040: G = if unconstrained { Bytes2::xor(&__v_912, &__v_944) } else { bytes2_xor_value(__v_912, __v_944, record) };
+    let __v_1041: G = if unconstrained { Bytes2::xor(&__v_913, &__v_945) } else { bytes2_xor_value(__v_913, __v_945, record) };
+    let __v_1042: G = if unconstrained { Bytes2::xor(&__v_914, &__v_946) } else { bytes2_xor_value(__v_914, __v_946, record) };
+    let __v_1043: G = if unconstrained { Bytes2::xor(&__v_915, &__v_947) } else { bytes2_xor_value(__v_915, __v_947, record) };
+    let __v_1044: G = if unconstrained { Bytes2::xor(&__v_916, &__v_948) } else { bytes2_xor_value(__v_916, __v_948, record) };
+    let __v_1045: G = if unconstrained { Bytes2::xor(&__v_917, &__v_949) } else { bytes2_xor_value(__v_917, __v_949, record) };
+    let __v_1046: G = if unconstrained { Bytes2::xor(&__v_918, &__v_950) } else { bytes2_xor_value(__v_918, __v_950, record) };
+    let __v_1047: G = if unconstrained { Bytes2::xor(&__v_919, &__v_951) } else { bytes2_xor_value(__v_919, __v_951, record) };
+    let __v_1048: G = if unconstrained { Bytes2::xor(&__v_920, &__v_952) } else { bytes2_xor_value(__v_920, __v_952, record) };
+    let __v_1049: G = if unconstrained { Bytes2::xor(&__v_921, &__v_953) } else { bytes2_xor_value(__v_921, __v_953, record) };
+    let __v_1050: G = if unconstrained { Bytes2::xor(&__v_922, &__v_954) } else { bytes2_xor_value(__v_922, __v_954, record) };
+    let __v_1051: G = if unconstrained { Bytes2::xor(&__v_923, &__v_955) } else { bytes2_xor_value(__v_923, __v_955, record) };
+    let __v_1052: G = if unconstrained { Bytes2::xor(&__v_924, &__v_956) } else { bytes2_xor_value(__v_924, __v_956, record) };
+    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_72] = [__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[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_73: usize = 1;
+const IN_73: usize = 1;
+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_73], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_0 + __v_3);
+    let __ret: [G; OUT_73] = [__v_2, __v_4];
+    record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_74: usize = 1;
+const IN_74: usize = 1;
+const OUT_74: usize = 2;
+fn aiur_fn_74(
+  inp: [G; IN_74],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_74], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __io_read: [G; 2] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 2)?; let __arr: [G; 2] = __data[..2].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = G::from_u64(256);
+    let __v_5: G = (__v_4 * __v_3);
+    let __v_6: G = (__v_2 + __v_5);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = (__v_0 + __v_7);
+    let __ret: [G; OUT_74] = [__v_6, __v_8];
+    record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_75: usize = 1;
+const IN_75: usize = 1;
+const OUT_75: usize = 10;
+fn aiur_fn_75(
+  inp: [G; IN_75],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_75], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __io_read: [G; 2] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 2)?; let __arr: [G; 2] = __data[..2].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = G::from_u64(256);
+    let __v_5: G = (__v_4 * __v_3);
+    let __v_6: G = (__v_2 + __v_5);
+    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(2);
+    let __v_14: G = (__v_0 + __v_13);
+    let __ret: [G; OUT_75] = [__v_6, __v_2, __v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14];
+    record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_76: usize = 1;
+const IN_76: usize = 1;
+const OUT_76: usize = 2;
+fn aiur_fn_76(
+  inp: [G; IN_76],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_76], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __io_read: [G; 4] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 4)?; let __arr: [G; 4] = __data[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = __io_read[2];
+    let __v_5: G = __io_read[3];
+    let __v_6: G = G::from_u64(256);
+    let __v_7: G = (__v_6 * __v_3);
+    let __v_8: G = G::from_u64(65536);
+    let __v_9: G = (__v_8 * __v_4);
+    let __v_10: G = G::from_u64(16777216);
+    let __v_11: G = (__v_10 * __v_5);
+    let __v_12: G = (__v_9 + __v_11);
+    let __v_13: G = (__v_7 + __v_12);
+    let __v_14: G = (__v_2 + __v_13);
+    let __v_15: G = G::from_u64(4);
+    let __v_16: G = (__v_0 + __v_15);
+    let __ret: [G; OUT_76] = [__v_14, __v_16];
+    record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_77: usize = 1;
+const IN_77: usize = 1;
+const OUT_77: usize = 10;
+fn aiur_fn_77(
+  inp: [G; IN_77],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_77], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __io_read: [G; 4] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 4)?; let __arr: [G; 4] = __data[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = __io_read[2];
+    let __v_5: G = __io_read[3];
+    let __v_6: G = G::from_u64(256);
+    let __v_7: G = (__v_6 * __v_3);
+    let __v_8: G = G::from_u64(65536);
+    let __v_9: G = (__v_8 * __v_4);
+    let __v_10: G = G::from_u64(16777216);
+    let __v_11: G = (__v_10 * __v_5);
+    let __v_12: G = (__v_9 + __v_11);
+    let __v_13: G = (__v_7 + __v_12);
+    let __v_14: G = (__v_2 + __v_13);
+    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(4);
+    let __v_20: G = (__v_0 + __v_19);
+    let __ret: [G; OUT_77] = [__v_14, __v_2, __v_3, __v_4, __v_5, __v_15, __v_16, __v_17, __v_18, __v_20];
+    record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_78: usize = 1;
+const IN_78: usize = 1;
+const OUT_78: usize = 9;
+fn aiur_fn_78(
+  inp: [G; IN_78],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_78], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = __io_read[2];
+    let __v_5: G = __io_read[3];
+    let __v_6: G = __io_read[4];
+    let __v_7: G = __io_read[5];
+    let __v_8: G = __io_read[6];
+    let __v_9: G = __io_read[7];
+    let __v_10: G = G::from_u64(8);
+    let __v_11: G = (__v_0 + __v_10);
+    let __ret: [G; OUT_78] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
+    record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_79: usize = 1;
+const IN_79: usize = 1;
+const OUT_79: usize = 2;
+fn aiur_fn_79(
+  inp: [G; IN_79],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_79], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __ret: [G; OUT_79] = [__v_10, __v_9];
+    record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_80: usize = 1;
+const IN_80: usize = 1;
+const OUT_80: usize = 33;
+fn aiur_fn_80(
+  inp: [G; IN_80],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_80], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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_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_78] = { let __args: [G; IN_78] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __v_21: G = __r_arr[2];
+    let __v_22: G = __r_arr[3];
+    let __v_23: G = __r_arr[4];
+    let __v_24: G = __r_arr[5];
+    let __v_25: G = __r_arr[6];
+    let __v_26: G = __r_arr[7];
+    let __v_27: G = __r_arr[8];
+    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __v_30: G = __r_arr[2];
+    let __v_31: G = __r_arr[3];
+    let __v_32: G = __r_arr[4];
+    let __v_33: G = __r_arr[5];
+    let __v_34: G = __r_arr[6];
+    let __v_35: G = __r_arr[7];
+    let __v_36: G = __r_arr[8];
+    let __ret: [G; OUT_80] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_81: usize = 2;
+const IN_81: usize = 2;
+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_81], 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; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&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_81] = [__v_4, __v_0];
+        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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_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 = G::from_u64(1);
+        let __v_36: G = (__v_1 - __v_35);
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_34, __v_36]; 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_37: G = __r_arr[0];
+        let __v_38: G = __r_arr[1];
+        let __v_39: G = G::from_u64(0);
+        let __v_40: G = { let __values: [G; 34] = [__v_39, __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_37]; 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_81] = [__v_40, __v_38];
+        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_82: usize = 4;
+const IN_82: usize = 4;
+const OUT_82: usize = 8;
+fn aiur_fn_82(
+  inp: [G; IN_82],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_82], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      16u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      32u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(2);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      48u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(3);
+        let __v_10: G = G::from_u64(3);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      64u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(4);
+        let __v_10: G = G::from_u64(4);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      80u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(5);
+        let __v_10: G = G::from_u64(5);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      128u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(1);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      144u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = G::from_u64(1);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      160u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(2);
+        let __v_10: G = G::from_u64(1);
+        let __ret: [G; OUT_82] = [__v_8, __v_9, __v_10, __v_6, __v_5, __v_7, __v_2, __v_3];
+        record.function_queries[82].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 __ret: [G; OUT_82] = [__v_6, __v_7, __v_7, __v_7, __v_5, __v_1, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_6: G = G::from_u64(2);
+        let __v_7: G = G::from_u64(2);
+        let __ret: [G; OUT_82] = [__v_6, __v_7, __v_7, __v_7, __v_5, __v_1, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_6: G = G::from_u64(3);
+        let __v_7: G = G::from_u64(3);
+        let __ret: [G; OUT_82] = [__v_6, __v_7, __v_7, __v_7, __v_5, __v_1, __v_2, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(4);
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_8, __v_6, __v_9, __v_9, __v_5, __v_1, __v_7, __v_3];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      20u64 => {
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = true; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(4);
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_8, __v_6, __v_9, __v_9, __v_5, __v_1, __v_2, __v_7];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = __r_arr[2];
+        let __v_9: G = __r_arr[3];
+        let __v_10: G = __r_arr[4];
+        let __v_11: G = __r_arr[5];
+        let __v_12: G = __r_arr[6];
+        let __v_13: G = __r_arr[7];
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_11, __v_12, __v_13]; 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_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(5);
+        let __v_23: 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 __v_24: G = { let __values: [G; 4] = [__v_14, __v_15, __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_25: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_22, __v_23, __v_24, __v_25, __v_18, __v_19, __v_20, __v_21];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = __r_arr[2];
+        let __v_9: G = __r_arr[3];
+        let __v_10: G = __r_arr[4];
+        let __v_11: G = __r_arr[5];
+        let __v_12: G = __r_arr[6];
+        let __v_13: G = __r_arr[7];
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_11, __v_12, __v_13]; 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_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(6);
+        let __v_23: 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 __v_24: G = { let __values: [G; 4] = [__v_14, __v_15, __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_25: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_22, __v_23, __v_24, __v_25, __v_18, __v_19, __v_20, __v_21];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = __r_arr[2];
+        let __v_9: G = __r_arr[3];
+        let __v_10: G = __r_arr[4];
+        let __v_11: G = __r_arr[5];
+        let __v_12: G = __r_arr[6];
+        let __v_13: G = __r_arr[7];
+        let __v_14: G = G::from_u64(7);
+        let __v_15: 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 __v_16: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_14, __v_15, __v_16, __v_16, __v_10, __v_11, __v_12, __v_13];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_5, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = __r_arr[2];
+        let __v_9: G = __r_arr[3];
+        let __v_10: G = __r_arr[4];
+        let __v_11: G = __r_arr[5];
+        let __v_12: G = __r_arr[6];
+        let __v_13: G = __r_arr[7];
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_11, __v_12, __v_13]; 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_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(8);
+        let __v_23: 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 __v_24: G = { let __values: [G; 4] = [__v_14, __v_15, __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_25: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_22, __v_23, __v_24, __v_25, __v_18, __v_19, __v_20, __v_21];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_83: usize = 5;
+const IN_83: usize = 5;
+const OUT_83: usize = 5;
+fn aiur_fn_83(
+  inp: [G; IN_83],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_83], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    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; 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_83] = [__v_7, __v_0, __v_1, __v_2, __v_3];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0, __v_1, __v_2, __v_3]; 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_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 = G::from_u64(1);
+        let __v_14: G = (__v_4 - __v_13);
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_9, __v_10, __v_11, __v_12, __v_14]; 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_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 = G::from_u64(0);
+        let __v_21: G = { let __values: [G; 6] = [__v_20, __v_5, __v_6, __v_7, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_83] = [__v_21, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_84: usize = 5;
+const IN_84: usize = 5;
+const OUT_84: usize = 10;
+fn aiur_fn_84(
+  inp: [G; IN_84],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_84], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0, __v_1, __v_2, __v_3]; 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_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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_4]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_9, __v_10, __v_11, __v_12, __v_13]; 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_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 __ret: [G; OUT_84] = [__v_5, __v_6, __v_7, __v_8, __v_15, __v_16, __v_17, __v_18, __v_19, __v_14];
+    record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_85: usize = 6;
+const IN_85: usize = 6;
+const OUT_85: usize = 6;
+fn aiur_fn_85(
+  inp: [G; IN_85],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_85], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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_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; 7] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_85] = [__v_8, __v_0, __v_1, __v_2, __v_3, __v_4];
+        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = __r_arr[2];
+        let __v_9: G = __r_arr[3];
+        let __v_10: G = __r_arr[4];
+        let __v_11: G = __r_arr[5];
+        let __v_12: G = __r_arr[6];
+        let __v_13: G = __r_arr[7];
+        let __v_14: G = __r_arr[8];
+        let __v_15: G = __r_arr[9];
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = (__v_5 - __v_16);
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_17]; 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_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];
+        let __v_24: G = G::from_u64(0);
+        let __v_25: G = { let __values: [G; 7] = [__v_24, __v_6, __v_7, __v_8, __v_9, __v_10, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_85] = [__v_25, __v_19, __v_20, __v_21, __v_22, __v_23];
+        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_86: usize = 5;
+const IN_86: usize = 5;
+const OUT_86: usize = 10;
+fn aiur_fn_86(
+  inp: [G; IN_86],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_86], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_4]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_6, __v_1, __v_2, __v_3, __v_7]; 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_9: G = __r_arr[0];
+        let __v_10: G = __r_arr[1];
+        let __v_11: G = __r_arr[2];
+        let __v_12: G = __r_arr[3];
+        let __v_13: G = __r_arr[4];
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_8]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_15]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_17]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __v_20: G = G::from_u64(0);
+        let __ret: [G; OUT_86] = [__v_20, __v_9, __v_14, __v_16, __v_18, __v_10, __v_11, __v_12, __v_13, __v_19];
+        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_4]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_86] = [__v_9, __v_7, __v_10, __v_10, __v_10, __v_6, __v_1, __v_2, __v_3, __v_8];
+        record.function_queries[86].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(2);
+        let __ret: [G; OUT_86] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_6, __v_1, __v_2, __v_3, __v_4];
+        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_7: G = G::from_u64(3);
+        let __v_8: G = G::from_u64(3);
+        let __ret: [G; OUT_86] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_6, __v_1, __v_2, __v_3, __v_4];
+        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_87: usize = 1;
+const IN_87: usize = 1;
+const OUT_87: usize = 61;
+fn aiur_fn_87(
+  inp: [G; IN_87],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_87], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_4]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_6]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_8]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __v_11: G = (__v_10 + __v_1);
+    let __v_12: G = (__v_11 + __v_3);
+    let __v_13: G = (__v_12 + __v_5);
+    let __v_14: G = (__v_13 + __v_7);
+    let __v_15: G = (__v_14 + __v_9);
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10, __v_11, __v_12, __v_13, __v_14]; 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_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 = __r_arr[6];
+    let __v_23: G = __r_arr[7];
+    let __v_24: G = __r_arr[8];
+    let __v_25: G = __r_arr[9];
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_25]; let __cu = true; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_21, __v_22, __v_23, __v_24, __v_27, __v_26]; 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_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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_33]; let __cu = true; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_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_77] = { let __args: [G; IN_77] = [__v_43]; let __cu = true; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_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_77] = { let __args: [G; IN_77] = [__v_53]; let __cu = true; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_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_77] = { let __args: [G; IN_77] = [__v_63]; let __cu = true; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_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_77] = { let __args: [G; IN_77] = [__v_73]; let __cu = true; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_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_77] = { let __args: [G; IN_77] = [__v_83]; let __cu = true; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_84: G = __r_arr[0];
+    let __v_85: G = __r_arr[1];
+    let __v_86: G = __r_arr[2];
+    let __v_87: G = __r_arr[3];
+    let __v_88: G = __r_arr[4];
+    let __v_89: G = __r_arr[5];
+    let __v_90: G = __r_arr[6];
+    let __v_91: G = __r_arr[7];
+    let __v_92: G = __r_arr[8];
+    let __v_93: G = __r_arr[9];
+    if (__v_29 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
+    }
+    if (__v_30 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+    }
+    if (__v_31 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
+    }
+    if (__v_32 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+    }
+    if (__v_93 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+    }
+    let __ret: [G; OUT_87] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_28, __v_34, __v_44, __v_54, __v_64, __v_74, __v_84, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_15];
+    record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_88: usize = 49;
+const IN_88: usize = 49;
+const OUT_88: usize = 1;
+fn aiur_fn_88(
+  inp: [G; IN_88],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_88], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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 = 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 = { let __values: [G; 10] = [__v_54, __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(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 10] = [__v_53, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_55]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 10] = [__v_52, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_58: G = { let __values: [G; 10] = [__v_51, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_57]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 10] = [__v_50, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_58]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 10] = [__v_49, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_59]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_88] = [__v_60];
+    record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_89: usize = 2;
+const IN_89: usize = 2;
+const OUT_89: usize = 3;
+fn aiur_fn_89(
+  inp: [G; IN_89],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_89], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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; 14] = [__v_2, __v_3, __v_3, __v_3, __v_3, __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(&14).ok_or(ExecError::InvalidMemorySize(14))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_89] = [__v_4, __v_7, __v_0];
+        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = __r_arr[9];
+        let __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];
+        let __v_50: G = __r_arr[48];
+        let __v_51: G = __r_arr[49];
+        let __v_52: G = __r_arr[50];
+        let __v_53: G = __r_arr[51];
+        let __v_54: G = __r_arr[52];
+        let __v_55: G = __r_arr[53];
+        let __v_56: G = __r_arr[54];
+        let __v_57: G = __r_arr[55];
+        let __v_58: G = __r_arr[56];
+        let __v_59: G = __r_arr[57];
+        let __v_60: G = __r_arr[58];
+        let __v_61: G = __r_arr[59];
+        let __v_62: G = __r_arr[60];
+        let __v_63: G = G::from_u64(1);
+        let __v_64: G = (__v_1 - __v_63);
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_62, __v_64]; 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_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; 14] = [__v_68, __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_65]; let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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_66]; 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_70: G = __r_arr[0];
+        let __ret: [G; OUT_89] = [__v_69, __v_70, __v_67];
+        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_90: usize = 1;
+const IN_90: usize = 1;
+const OUT_90: usize = 3;
+fn aiur_fn_90(
+  inp: [G; IN_90],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_90], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_90] = [__v_3, __v_4, __v_2];
+        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_4, __v_3]; 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __v_7: G = G::from_u64(1);
+        let __ret: [G; OUT_90] = [__v_7, __v_5, __v_6];
+        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_91: usize = 2;
+const IN_91: usize = 2;
+const OUT_91: usize = 2;
+fn aiur_fn_91(
+  inp: [G; IN_91],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_91], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_91] = [__v_4, __v_0];
+        record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        match __v_2.as_canonical_u64() {
+          65535u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_11, __v_7];
+            record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_91] = [__v_10, __v_7];
+            record.function_queries[91].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 = 9;
+fn aiur_fn_92(
+  inp: [G; IN_92],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_92], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = __r_arr[9];
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_20]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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_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_75] = { let __args: [G; IN_75] = [__v_30]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __v_33: G = __r_arr[2];
+    let __v_34: G = __r_arr[3];
+    let __v_35: G = __r_arr[4];
+    let __v_36: G = __r_arr[5];
+    let __v_37: G = __r_arr[6];
+    let __v_38: G = __r_arr[7];
+    let __v_39: G = __r_arr[8];
+    let __v_40: G = __r_arr[9];
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_40]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __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_75] = { let __args: [G; IN_75] = [__v_50]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __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_75] = { let __args: [G; IN_75] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __v_63: G = __r_arr[2];
+    let __v_64: G = __r_arr[3];
+    let __v_65: G = __r_arr[4];
+    let __v_66: G = __r_arr[5];
+    let __v_67: G = __r_arr[6];
+    let __v_68: G = __r_arr[7];
+    let __v_69: G = __r_arr[8];
+    let __v_70: G = __r_arr[9];
+    let __v_71: G = G::from_u64(0);
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = G::from_u64(0);
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(0);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = G::from_u64(1);
+    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_92] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70];
+    record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_93: usize = 1;
+const IN_93: usize = 1;
+const OUT_93: usize = 13;
+fn aiur_fn_93(
+  inp: [G; IN_93],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_93], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_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_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_75] = { let __args: [G; IN_75] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19, __v_10]; 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_20: G = __r_arr[0];
+    let __v_21: G = __r_arr[1];
+    let __v_22: G = __r_arr[2];
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_22]; 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_23: G = __r_arr[0];
+    let __v_24: G = __r_arr[1];
+    let __v_25: G = __r_arr[2];
+    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_25, __v_10]; 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_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = { let __values: [G; 10] = [__v_28, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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 __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_29]; 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_30: G = __r_arr[0];
+    let __ret: [G; OUT_93] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_30, __v_20, __v_23, __v_24, __v_26, __v_27];
+    record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_94: usize = 5;
+const IN_94: usize = 5;
+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_94], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_94] = [__v_12];
+    record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_95: usize = 33;
+const IN_95: usize = 33;
+const OUT_95: usize = 1;
+fn aiur_fn_95(
+  inp: [G; IN_95],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_95], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_28, __v_29, __v_30, __v_31, __v_32]; 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_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_24, __v_25, __v_26, __v_27, __v_33]; 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_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_20, __v_21, __v_22, __v_23, __v_34]; 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_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_16, __v_17, __v_18, __v_19, __v_35]; 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_36: G = __r_arr[0];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_12, __v_13, __v_14, __v_15, __v_36]; 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_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_8, __v_9, __v_10, __v_11, __v_37]; 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_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_4, __v_5, __v_6, __v_7, __v_38]; 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_39: G = __r_arr[0];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_0, __v_1, __v_2, __v_3, __v_39]; 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_40: G = __r_arr[0];
+    let __ret: [G; OUT_95] = [__v_40];
+    record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_96: usize = 32;
+const IN_96: usize = 32;
+const OUT_96: usize = 32;
+fn aiur_fn_96(
+  inp: [G; IN_96],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_96], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __ret: [G; OUT_96] = [__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];
+    record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_97: usize = 4;
+const IN_97: usize = 4;
+const OUT_97: usize = 1;
+fn aiur_fn_97(
+  inp: [G; IN_97],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_97], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_97] = [__v_3];
+        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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_4: G = __io_read[0];
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 + __v_5);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 - __v_7);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __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_97] = { let __args: [G; IN_97] = [__v_0, __v_6, __v_8, __v_10]; 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_11: G = __r_arr[0];
+        let __ret: [G; OUT_97] = [__v_11];
+        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_98: usize = 7;
+const IN_98: usize = 7;
+const OUT_98: usize = 1;
+fn aiur_fn_98(
+  inp: [G; IN_98],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_98], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = 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(64);
+    let __v_8: G = { let __a_val = __v_2.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() {
+      0u64 => {
+        let __io_read: [G; 64] = { 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, 64)?; let __arr: [G; 64] = __data[..64].try_into().unwrap(); __arr };
+        let __v_9: G = __io_read[0];
+        let __v_10: G = __io_read[1];
+        let __v_11: G = __io_read[2];
+        let __v_12: G = __io_read[3];
+        let __v_13: G = __io_read[4];
+        let __v_14: G = __io_read[5];
+        let __v_15: G = __io_read[6];
+        let __v_16: G = __io_read[7];
+        let __v_17: G = __io_read[8];
+        let __v_18: G = __io_read[9];
+        let __v_19: G = __io_read[10];
+        let __v_20: G = __io_read[11];
+        let __v_21: G = __io_read[12];
+        let __v_22: G = __io_read[13];
+        let __v_23: G = __io_read[14];
+        let __v_24: G = __io_read[15];
+        let __v_25: G = __io_read[16];
+        let __v_26: G = __io_read[17];
+        let __v_27: G = __io_read[18];
+        let __v_28: G = __io_read[19];
+        let __v_29: G = __io_read[20];
+        let __v_30: G = __io_read[21];
+        let __v_31: G = __io_read[22];
+        let __v_32: G = __io_read[23];
+        let __v_33: G = __io_read[24];
+        let __v_34: G = __io_read[25];
+        let __v_35: G = __io_read[26];
+        let __v_36: G = __io_read[27];
+        let __v_37: G = __io_read[28];
+        let __v_38: G = __io_read[29];
+        let __v_39: G = __io_read[30];
+        let __v_40: G = __io_read[31];
+        let __v_41: G = __io_read[32];
+        let __v_42: G = __io_read[33];
+        let __v_43: G = __io_read[34];
+        let __v_44: G = __io_read[35];
+        let __v_45: G = __io_read[36];
+        let __v_46: G = __io_read[37];
+        let __v_47: G = __io_read[38];
+        let __v_48: G = __io_read[39];
+        let __v_49: G = __io_read[40];
+        let __v_50: G = __io_read[41];
+        let __v_51: G = __io_read[42];
+        let __v_52: G = __io_read[43];
+        let __v_53: G = __io_read[44];
+        let __v_54: G = __io_read[45];
+        let __v_55: G = __io_read[46];
+        let __v_56: G = __io_read[47];
+        let __v_57: G = __io_read[48];
+        let __v_58: G = __io_read[49];
+        let __v_59: G = __io_read[50];
+        let __v_60: G = __io_read[51];
+        let __v_61: G = __io_read[52];
+        let __v_62: G = __io_read[53];
+        let __v_63: G = __io_read[54];
+        let __v_64: G = __io_read[55];
+        let __v_65: G = __io_read[56];
+        let __v_66: G = __io_read[57];
+        let __v_67: G = __io_read[58];
+        let __v_68: G = __io_read[59];
+        let __v_69: G = __io_read[60];
+        let __v_70: G = __io_read[61];
+        let __v_71: G = __io_read[62];
+        let __v_72: G = __io_read[63];
+        let __v_73: G = G::from_u64(64);
+        let __v_74: G = (__v_2 - __v_73);
+        let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+        let __v_76: G = G::from_u64(15);
+        let __v_77: G = (__v_3 - __v_76);
+        let __v_78: G = G::from_bool((__v_77 == G::ZERO));
+        let __v_79: G = G::from_bool((__v_3 == G::ZERO));
+        let __v_80: G = (__v_75 * __v_78);
+        let __v_81: G = (__v_78 - __v_80);
+        let __v_82: G = (__v_75 + __v_81);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; 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: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_83: G = __loaded[0];
+        let __v_84: G = __loaded[1];
+        let __v_85: G = __loaded[2];
+        let __v_86: G = __loaded[3];
+        let __v_87: G = __loaded[4];
+        let __v_88: G = __loaded[5];
+        let __v_89: G = __loaded[6];
+        let __v_90: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[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_91: G = __r_arr[0];
+        let __v_92: G = (__v_75 * __v_91);
+        let __v_93: G = G::from_u64(2);
+        let __v_94: G = (__v_93 * __v_82);
+        let __v_95: G = G::from_u64(8);
+        let __v_96: G = (__v_95 * __v_92);
+        let __v_97: G = (__v_94 + __v_96);
+        let __v_98: G = (__v_79 + __v_97);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_99: G = __loaded[0];
+        let __v_100: G = __loaded[1];
+        let __v_101: G = __loaded[2];
+        let __v_102: G = __loaded[3];
+        let __v_103: G = __loaded[4];
+        let __v_104: G = __loaded[5];
+        let __v_105: G = __loaded[6];
+        let __v_106: G = __loaded[7];
+        let __v_107: G = __loaded[8];
+        let __v_108: G = __loaded[9];
+        let __v_109: G = __loaded[10];
+        let __v_110: G = __loaded[11];
+        let __v_111: G = __loaded[12];
+        let __v_112: G = __loaded[13];
+        let __v_113: G = __loaded[14];
+        let __v_114: G = __loaded[15];
+        let __v_115: G = __loaded[16];
+        let __v_116: G = __loaded[17];
+        let __v_117: G = __loaded[18];
+        let __v_118: G = __loaded[19];
+        let __v_119: G = __loaded[20];
+        let __v_120: G = __loaded[21];
+        let __v_121: G = __loaded[22];
+        let __v_122: G = __loaded[23];
+        let __v_123: G = __loaded[24];
+        let __v_124: G = __loaded[25];
+        let __v_125: G = __loaded[26];
+        let __v_126: G = __loaded[27];
+        let __v_127: G = __loaded[28];
+        let __v_128: G = __loaded[29];
+        let __v_129: G = __loaded[30];
+        let __v_130: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; 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: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_131: G = __loaded[0];
+        let __v_132: G = __loaded[1];
+        let __v_133: G = __loaded[2];
+        let __v_134: G = __loaded[3];
+        let __v_135: G = __loaded[4];
+        let __v_136: G = __loaded[5];
+        let __v_137: G = __loaded[6];
+        let __v_138: G = __loaded[7];
+        let __v_139: G = G::from_u64(64);
+        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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_130, __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_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_98]; 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_140: G = __r_arr[0];
+        let __v_141: G = __r_arr[1];
+        let __v_142: G = __r_arr[2];
+        let __v_143: G = __r_arr[3];
+        let __v_144: G = __r_arr[4];
+        let __v_145: G = __r_arr[5];
+        let __v_146: G = __r_arr[6];
+        let __v_147: G = __r_arr[7];
+        let __v_148: G = __r_arr[8];
+        let __v_149: G = __r_arr[9];
+        let __v_150: G = __r_arr[10];
+        let __v_151: G = __r_arr[11];
+        let __v_152: G = __r_arr[12];
+        let __v_153: G = __r_arr[13];
+        let __v_154: G = __r_arr[14];
+        let __v_155: G = __r_arr[15];
+        let __v_156: G = __r_arr[16];
+        let __v_157: G = __r_arr[17];
+        let __v_158: G = __r_arr[18];
+        let __v_159: G = __r_arr[19];
+        let __v_160: G = __r_arr[20];
+        let __v_161: G = __r_arr[21];
+        let __v_162: G = __r_arr[22];
+        let __v_163: G = __r_arr[23];
+        let __v_164: G = __r_arr[24];
+        let __v_165: G = __r_arr[25];
+        let __v_166: G = __r_arr[26];
+        let __v_167: G = __r_arr[27];
+        let __v_168: G = __r_arr[28];
+        let __v_169: G = __r_arr[29];
+        let __v_170: G = __r_arr[30];
+        let __v_171: G = __r_arr[31];
+        match __v_75.as_canonical_u64() {
+          1u64 => {
+            let __v_172: G = G::from_u64(0);
+            let __v_173: G = { let __values: [G; 34] = [__v_172, __v_6, __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]; 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_98] = [__v_173];
+            record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            match __v_78.as_canonical_u64() {
+              1u64 => {
+                let __v_172: G = G::from_u64(103);
+                let __v_173: G = G::from_u64(230);
+                let __v_174: G = G::from_u64(9);
+                let __v_175: G = G::from_u64(106);
+                let __v_176: G = G::from_u64(133);
+                let __v_177: G = G::from_u64(174);
+                let __v_178: G = G::from_u64(103);
+                let __v_179: G = G::from_u64(187);
+                let __v_180: G = G::from_u64(114);
+                let __v_181: G = G::from_u64(243);
+                let __v_182: G = G::from_u64(110);
+                let __v_183: G = G::from_u64(60);
+                let __v_184: G = G::from_u64(58);
+                let __v_185: G = G::from_u64(245);
+                let __v_186: G = G::from_u64(79);
+                let __v_187: G = G::from_u64(165);
+                let __v_188: G = G::from_u64(127);
+                let __v_189: G = G::from_u64(82);
+                let __v_190: G = G::from_u64(14);
+                let __v_191: G = G::from_u64(81);
+                let __v_192: G = G::from_u64(140);
+                let __v_193: G = G::from_u64(104);
+                let __v_194: G = G::from_u64(5);
+                let __v_195: G = G::from_u64(155);
+                let __v_196: G = G::from_u64(171);
+                let __v_197: G = G::from_u64(217);
+                let __v_198: G = G::from_u64(131);
+                let __v_199: G = G::from_u64(31);
+                let __v_200: G = G::from_u64(25);
+                let __v_201: G = G::from_u64(205);
+                let __v_202: G = G::from_u64(224);
+                let __v_203: G = G::from_u64(91);
+                let __v_204: G = G::from_u64(64);
+                let __v_205: G = (__v_1 + __v_204);
+                let __v_206: G = G::from_u64(64);
+                let __v_207: G = (__v_2 - __v_206);
+                let __v_208: G = G::from_u64(0);
+                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_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: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                let __v_209: G = __loaded[0];
+                let __v_210: G = __loaded[1];
+                let __v_211: G = __loaded[2];
+                let __v_212: G = __loaded[3];
+                let __v_213: G = __loaded[4];
+                let __v_214: G = __loaded[5];
+                let __v_215: G = __loaded[6];
+                let __v_216: G = __loaded[7];
+                let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
+                let __v_217: G = __r_arr[0];
+                let __v_218: G = __r_arr[1];
+                let __v_219: G = __r_arr[2];
+                let __v_220: G = __r_arr[3];
+                let __v_221: G = __r_arr[4];
+                let __v_222: G = __r_arr[5];
+                let __v_223: G = __r_arr[6];
+                let __v_224: G = __r_arr[7];
+                let __v_225: G = { let __values: [G; 8] = [__v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224]; 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_226: G = { let __values: [G; 32] = [__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]; 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_227: G = G::from_u64(0);
+                let __v_228: G = { let __values: [G; 34] = [__v_227, __v_6, __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]; 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_98] = { let __args: [G; IN_98] = [__v_0, __v_205, __v_207, __v_208, __v_225, __v_226, __v_228]; 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_229: G = __r_arr[0];
+                let __ret: [G; OUT_98] = [__v_229];
+                record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_172: G = G::from_u64(64);
+                let __v_173: G = (__v_1 + __v_172);
+                let __v_174: G = G::from_u64(64);
+                let __v_175: G = (__v_2 - __v_174);
+                let __v_176: G = G::from_u64(1);
+                let __v_177: G = (__v_3 + __v_176);
+                let __v_178: G = { let __values: [G; 32] = [__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]; 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_98] = { let __args: [G; IN_98] = [__v_0, __v_173, __v_175, __v_177, __v_4, __v_178, __v_6]; 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_179: G = __r_arr[0];
+                let __ret: [G; OUT_98] = [__v_179];
+                record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_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: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __v_9: G = __loaded[0];
+            let __v_10: G = __loaded[1];
+            let __v_11: G = __loaded[2];
+            let __v_12: G = __loaded[3];
+            let __v_13: G = __loaded[4];
+            let __v_14: G = __loaded[5];
+            let __v_15: G = __loaded[6];
+            let __v_16: G = __loaded[7];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    match __v_11.as_canonical_u64() {
+                      0u64 => {
+                        match __v_12.as_canonical_u64() {
+                          0u64 => {
+                            match __v_13.as_canonical_u64() {
+                              0u64 => {
+                                match __v_14.as_canonical_u64() {
+                                  0u64 => {
+                                    match __v_15.as_canonical_u64() {
+                                      0u64 => {
+                                        match __v_16.as_canonical_u64() {
+                                          0u64 => {
+                                            let __v_17: G = G::from_u64(0);
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].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 __v_29: G = __loaded[11];
+                                            let __v_30: G = __loaded[12];
+                                            let __v_31: G = __loaded[13];
+                                            let __v_32: G = __loaded[14];
+                                            let __v_33: G = __loaded[15];
+                                            let __v_34: G = __loaded[16];
+                                            let __v_35: G = __loaded[17];
+                                            let __v_36: G = __loaded[18];
+                                            let __v_37: G = __loaded[19];
+                                            let __v_38: G = __loaded[20];
+                                            let __v_39: G = __loaded[21];
+                                            let __v_40: G = __loaded[22];
+                                            let __v_41: G = __loaded[23];
+                                            let __v_42: G = __loaded[24];
+                                            let __v_43: G = __loaded[25];
+                                            let __v_44: G = __loaded[26];
+                                            let __v_45: G = __loaded[27];
+                                            let __v_46: G = __loaded[28];
+                                            let __v_47: G = __loaded[29];
+                                            let __v_48: G = __loaded[30];
+                                            let __v_49: G = __loaded[31];
+                                            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 = G::from_u64(0);
+                                            let __v_78: G = G::from_u64(0);
+                                            let __v_79: G = G::from_u64(0);
+                                            let __v_80: G = G::from_u64(0);
+                                            let __v_81: G = G::from_u64(0);
+                                            let __v_82: G = G::from_u64(0);
+                                            let __v_83: G = G::from_u64(0);
+                                            let __v_84: G = G::from_u64(0);
+                                            let __v_85: G = G::from_u64(0);
+                                            let __v_86: G = G::from_u64(0);
+                                            let __v_87: G = G::from_u64(0);
+                                            let __v_88: G = G::from_u64(0);
+                                            let __v_89: G = G::from_u64(0);
+                                            let __v_90: G = G::from_u64(0);
+                                            let __v_91: G = G::from_u64(0);
+                                            let __v_92: G = G::from_u64(0);
+                                            let __v_93: G = G::from_u64(0);
+                                            let __v_94: G = G::from_u64(0);
+                                            let __v_95: G = G::from_u64(0);
+                                            let __v_96: G = G::from_u64(0);
+                                            let __v_97: G = G::from_u64(0);
+                                            let __v_98: G = G::from_u64(0);
+                                            let __v_99: G = G::from_u64(0);
+                                            let __v_100: G = G::from_u64(0);
+                                            let __v_101: G = G::from_u64(0);
+                                            let __v_102: G = G::from_u64(0);
+                                            let __v_103: G = G::from_u64(0);
+                                            let __v_104: G = G::from_u64(0);
+                                            let __v_105: G = G::from_u64(0);
+                                            let __v_106: G = G::from_u64(0);
+                                            let __v_107: G = G::from_u64(0);
+                                            let __v_108: G = G::from_u64(0);
+                                            let __v_109: G = G::from_u64(0);
+                                            let __v_110: G = G::from_u64(0);
+                                            let __v_111: G = G::from_u64(0);
+                                            let __v_112: G = G::from_u64(0);
+                                            let __v_113: G = G::from_u64(0);
+                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; 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: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __v_114: G = __loaded[0];
+                                            let __v_115: G = __loaded[1];
+                                            let __v_116: G = __loaded[2];
+                                            let __v_117: G = __loaded[3];
+                                            let __v_118: G = __loaded[4];
+                                            let __v_119: G = __loaded[5];
+                                            let __v_120: G = __loaded[6];
+                                            let __v_121: G = __loaded[7];
+                                            let __v_122: G = G::from_u64(0);
+                                            let __v_123: G = G::from_u64(11);
+                                            let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_18, __v_19, __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]; 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_124: G = __r_arr[0];
+                                            let __v_125: G = __r_arr[1];
+                                            let __v_126: G = __r_arr[2];
+                                            let __v_127: G = __r_arr[3];
+                                            let __v_128: G = __r_arr[4];
+                                            let __v_129: G = __r_arr[5];
+                                            let __v_130: G = __r_arr[6];
+                                            let __v_131: G = __r_arr[7];
+                                            let __v_132: G = __r_arr[8];
+                                            let __v_133: G = __r_arr[9];
+                                            let __v_134: G = __r_arr[10];
+                                            let __v_135: G = __r_arr[11];
+                                            let __v_136: G = __r_arr[12];
+                                            let __v_137: G = __r_arr[13];
+                                            let __v_138: G = __r_arr[14];
+                                            let __v_139: G = __r_arr[15];
+                                            let __v_140: G = __r_arr[16];
+                                            let __v_141: G = __r_arr[17];
+                                            let __v_142: G = __r_arr[18];
+                                            let __v_143: G = __r_arr[19];
+                                            let __v_144: G = __r_arr[20];
+                                            let __v_145: G = __r_arr[21];
+                                            let __v_146: G = __r_arr[22];
+                                            let __v_147: G = __r_arr[23];
+                                            let __v_148: G = __r_arr[24];
+                                            let __v_149: G = __r_arr[25];
+                                            let __v_150: G = __r_arr[26];
+                                            let __v_151: G = __r_arr[27];
+                                            let __v_152: G = __r_arr[28];
+                                            let __v_153: G = __r_arr[29];
+                                            let __v_154: G = __r_arr[30];
+                                            let __v_155: G = __r_arr[31];
+                                            let __v_156: G = { let __values: [G; 34] = [__v_17, __v_6, __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_151, __v_152, __v_153, __v_154, __v_155]; 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_98] = [__v_156];
+                                            record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __ret: [G; OUT_98] = [__v_6];
+                                            record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_98] = [__v_6];
+                                        record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_98] = [__v_6];
+                                    record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_98] = [__v_6];
+                                record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_98] = [__v_6];
+                            record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_98] = [__v_6];
+                        record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_98] = [__v_6];
+                    record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_98] = [__v_6];
+                record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            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_97] = { let __args: [G; IN_97] = [__v_0, __v_1, __v_2, __v_11]; 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_12: G = __r_arr[0];
+            let __v_13: G = G::from_u64(64);
+            let __v_14: G = (__v_13 - __v_2);
+            let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_12, __v_14]; 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_15: G = __r_arr[0];
+            let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_15]; 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_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 = __r_arr[6];
+            let __v_23: G = __r_arr[7];
+            let __v_24: G = __r_arr[8];
+            let __v_25: G = __r_arr[9];
+            let __v_26: G = __r_arr[10];
+            let __v_27: G = __r_arr[11];
+            let __v_28: G = __r_arr[12];
+            let __v_29: G = __r_arr[13];
+            let __v_30: G = __r_arr[14];
+            let __v_31: G = __r_arr[15];
+            let __v_32: G = __r_arr[16];
+            let __v_33: G = __r_arr[17];
+            let __v_34: G = __r_arr[18];
+            let __v_35: G = __r_arr[19];
+            let __v_36: G = __r_arr[20];
+            let __v_37: G = __r_arr[21];
+            let __v_38: G = __r_arr[22];
+            let __v_39: G = __r_arr[23];
+            let __v_40: G = __r_arr[24];
+            let __v_41: G = __r_arr[25];
+            let __v_42: G = __r_arr[26];
+            let __v_43: G = __r_arr[27];
+            let __v_44: G = __r_arr[28];
+            let __v_45: G = __r_arr[29];
+            let __v_46: G = __r_arr[30];
+            let __v_47: G = __r_arr[31];
+            let __v_48: G = __r_arr[32];
+            let __v_49: G = __r_arr[33];
+            let __v_50: G = __r_arr[34];
+            let __v_51: G = __r_arr[35];
+            let __v_52: G = __r_arr[36];
+            let __v_53: G = __r_arr[37];
+            let __v_54: G = __r_arr[38];
+            let __v_55: G = __r_arr[39];
+            let __v_56: G = __r_arr[40];
+            let __v_57: G = __r_arr[41];
+            let __v_58: G = __r_arr[42];
+            let __v_59: G = __r_arr[43];
+            let __v_60: G = __r_arr[44];
+            let __v_61: G = __r_arr[45];
+            let __v_62: G = __r_arr[46];
+            let __v_63: G = __r_arr[47];
+            let __v_64: G = __r_arr[48];
+            let __v_65: G = __r_arr[49];
+            let __v_66: G = __r_arr[50];
+            let __v_67: G = __r_arr[51];
+            let __v_68: G = __r_arr[52];
+            let __v_69: G = __r_arr[53];
+            let __v_70: G = __r_arr[54];
+            let __v_71: G = __r_arr[55];
+            let __v_72: G = __r_arr[56];
+            let __v_73: G = __r_arr[57];
+            let __v_74: G = __r_arr[58];
+            let __v_75: G = __r_arr[59];
+            let __v_76: G = __r_arr[60];
+            let __v_77: G = __r_arr[61];
+            let __v_78: G = __r_arr[62];
+            let __v_79: G = __r_arr[63];
+            let __v_80: G = G::from_bool((__v_3 == G::ZERO));
+            let __v_81: G = G::from_u64(2);
+            let __v_82: G = G::from_u64(8);
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; 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: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __v_83: G = __loaded[0];
+            let __v_84: G = __loaded[1];
+            let __v_85: G = __loaded[2];
+            let __v_86: G = __loaded[3];
+            let __v_87: G = __loaded[4];
+            let __v_88: G = __loaded[5];
+            let __v_89: G = __loaded[6];
+            let __v_90: G = __loaded[7];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[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_91: G = __r_arr[0];
+            let __v_92: G = (__v_82 * __v_91);
+            let __v_93: G = (__v_81 + __v_92);
+            let __v_94: G = (__v_80 + __v_93);
+            let __v_95: G = G::from_u64(0);
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+            let __v_96: G = __loaded[0];
+            let __v_97: G = __loaded[1];
+            let __v_98: G = __loaded[2];
+            let __v_99: G = __loaded[3];
+            let __v_100: G = __loaded[4];
+            let __v_101: G = __loaded[5];
+            let __v_102: G = __loaded[6];
+            let __v_103: G = __loaded[7];
+            let __v_104: G = __loaded[8];
+            let __v_105: G = __loaded[9];
+            let __v_106: G = __loaded[10];
+            let __v_107: G = __loaded[11];
+            let __v_108: G = __loaded[12];
+            let __v_109: G = __loaded[13];
+            let __v_110: G = __loaded[14];
+            let __v_111: G = __loaded[15];
+            let __v_112: G = __loaded[16];
+            let __v_113: G = __loaded[17];
+            let __v_114: G = __loaded[18];
+            let __v_115: G = __loaded[19];
+            let __v_116: G = __loaded[20];
+            let __v_117: G = __loaded[21];
+            let __v_118: G = __loaded[22];
+            let __v_119: G = __loaded[23];
+            let __v_120: G = __loaded[24];
+            let __v_121: G = __loaded[25];
+            let __v_122: G = __loaded[26];
+            let __v_123: G = __loaded[27];
+            let __v_124: G = __loaded[28];
+            let __v_125: G = __loaded[29];
+            let __v_126: G = __loaded[30];
+            let __v_127: G = __loaded[31];
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; 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: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __v_128: G = __loaded[0];
+            let __v_129: G = __loaded[1];
+            let __v_130: G = __loaded[2];
+            let __v_131: G = __loaded[3];
+            let __v_132: G = __loaded[4];
+            let __v_133: G = __loaded[5];
+            let __v_134: G = __loaded[6];
+            let __v_135: G = __loaded[7];
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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_16, __v_17, __v_18, __v_19, __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_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_2, __v_94]; 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_136: G = __r_arr[0];
+            let __v_137: G = __r_arr[1];
+            let __v_138: G = __r_arr[2];
+            let __v_139: G = __r_arr[3];
+            let __v_140: G = __r_arr[4];
+            let __v_141: G = __r_arr[5];
+            let __v_142: G = __r_arr[6];
+            let __v_143: G = __r_arr[7];
+            let __v_144: G = __r_arr[8];
+            let __v_145: G = __r_arr[9];
+            let __v_146: G = __r_arr[10];
+            let __v_147: G = __r_arr[11];
+            let __v_148: G = __r_arr[12];
+            let __v_149: G = __r_arr[13];
+            let __v_150: G = __r_arr[14];
+            let __v_151: G = __r_arr[15];
+            let __v_152: G = __r_arr[16];
+            let __v_153: G = __r_arr[17];
+            let __v_154: G = __r_arr[18];
+            let __v_155: G = __r_arr[19];
+            let __v_156: G = __r_arr[20];
+            let __v_157: G = __r_arr[21];
+            let __v_158: G = __r_arr[22];
+            let __v_159: G = __r_arr[23];
+            let __v_160: G = __r_arr[24];
+            let __v_161: G = __r_arr[25];
+            let __v_162: G = __r_arr[26];
+            let __v_163: G = __r_arr[27];
+            let __v_164: G = __r_arr[28];
+            let __v_165: G = __r_arr[29];
+            let __v_166: G = __r_arr[30];
+            let __v_167: G = __r_arr[31];
+            let __v_168: G = { let __values: [G; 34] = [__v_95, __v_6, __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]; 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_98] = [__v_168];
+            record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_99: usize = 3;
+const IN_99: usize = 3;
+const OUT_99: usize = 32;
+fn aiur_fn_99(
+  inp: [G; IN_99],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_99], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = G::from_u64(103);
+    let __v_4: G = G::from_u64(230);
+    let __v_5: G = G::from_u64(9);
+    let __v_6: G = G::from_u64(106);
+    let __v_7: G = G::from_u64(133);
+    let __v_8: G = G::from_u64(174);
+    let __v_9: G = G::from_u64(103);
+    let __v_10: G = G::from_u64(187);
+    let __v_11: G = G::from_u64(114);
+    let __v_12: G = G::from_u64(243);
+    let __v_13: G = G::from_u64(110);
+    let __v_14: G = G::from_u64(60);
+    let __v_15: G = G::from_u64(58);
+    let __v_16: G = G::from_u64(245);
+    let __v_17: G = G::from_u64(79);
+    let __v_18: G = G::from_u64(165);
+    let __v_19: G = G::from_u64(127);
+    let __v_20: G = G::from_u64(82);
+    let __v_21: G = G::from_u64(14);
+    let __v_22: G = G::from_u64(81);
+    let __v_23: G = G::from_u64(140);
+    let __v_24: G = G::from_u64(104);
+    let __v_25: G = G::from_u64(5);
+    let __v_26: G = G::from_u64(155);
+    let __v_27: G = G::from_u64(171);
+    let __v_28: G = G::from_u64(217);
+    let __v_29: G = G::from_u64(131);
+    let __v_30: G = G::from_u64(31);
+    let __v_31: G = G::from_u64(25);
+    let __v_32: G = G::from_u64(205);
+    let __v_33: G = G::from_u64(224);
+    let __v_34: G = G::from_u64(91);
+    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; 8] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; 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_45: 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_46: G = G::from_u64(1);
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = { let __values: [G; 34] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; 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_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_35, __v_44, __v_45, __v_48]; 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_49: 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_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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].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 __v_62: G = __loaded[12];
+    let __v_63: G = __loaded[13];
+    let __v_64: G = __loaded[14];
+    let __v_65: G = __loaded[15];
+    let __v_66: G = __loaded[16];
+    let __v_67: G = __loaded[17];
+    let __v_68: G = __loaded[18];
+    let __v_69: G = __loaded[19];
+    let __v_70: G = __loaded[20];
+    let __v_71: G = __loaded[21];
+    let __v_72: G = __loaded[22];
+    let __v_73: G = __loaded[23];
+    let __v_74: G = __loaded[24];
+    let __v_75: G = __loaded[25];
+    let __v_76: G = __loaded[26];
+    let __v_77: G = __loaded[27];
+    let __v_78: G = __loaded[28];
+    let __v_79: G = __loaded[29];
+    let __v_80: G = __loaded[30];
+    let __v_81: G = __loaded[31];
+    let __v_82: G = __loaded[32];
+    let __v_83: G = __loaded[33];
+    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__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]; 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_84: G = __r_arr[0];
+    let __v_85: G = __r_arr[1];
+    let __v_86: G = __r_arr[2];
+    let __v_87: G = __r_arr[3];
+    let __v_88: G = __r_arr[4];
+    let __v_89: G = __r_arr[5];
+    let __v_90: G = __r_arr[6];
+    let __v_91: G = __r_arr[7];
+    let __v_92: G = __r_arr[8];
+    let __v_93: G = __r_arr[9];
+    let __v_94: G = __r_arr[10];
+    let __v_95: G = __r_arr[11];
+    let __v_96: G = __r_arr[12];
+    let __v_97: G = __r_arr[13];
+    let __v_98: G = __r_arr[14];
+    let __v_99: G = __r_arr[15];
+    let __v_100: G = __r_arr[16];
+    let __v_101: G = __r_arr[17];
+    let __v_102: G = __r_arr[18];
+    let __v_103: G = __r_arr[19];
+    let __v_104: G = __r_arr[20];
+    let __v_105: G = __r_arr[21];
+    let __v_106: G = __r_arr[22];
+    let __v_107: G = __r_arr[23];
+    let __v_108: G = __r_arr[24];
+    let __v_109: G = __r_arr[25];
+    let __v_110: G = __r_arr[26];
+    let __v_111: G = __r_arr[27];
+    let __v_112: G = __r_arr[28];
+    let __v_113: G = __r_arr[29];
+    let __v_114: G = __r_arr[30];
+    let __v_115: G = __r_arr[31];
+    let __ret: [G; OUT_99] = [__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];
+    record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_100: usize = 64;
+const IN_100: usize = 64;
+const OUT_100: usize = 32;
+fn aiur_fn_100(
+  inp: [G; IN_100],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_100], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __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 = G::from_u64(103);
+    let __v_65: G = G::from_u64(230);
+    let __v_66: G = G::from_u64(9);
+    let __v_67: G = G::from_u64(106);
+    let __v_68: G = G::from_u64(133);
+    let __v_69: G = G::from_u64(174);
+    let __v_70: G = G::from_u64(103);
+    let __v_71: G = G::from_u64(187);
+    let __v_72: G = G::from_u64(114);
+    let __v_73: G = G::from_u64(243);
+    let __v_74: G = G::from_u64(110);
+    let __v_75: G = G::from_u64(60);
+    let __v_76: G = G::from_u64(58);
+    let __v_77: G = G::from_u64(245);
+    let __v_78: G = G::from_u64(79);
+    let __v_79: G = G::from_u64(165);
+    let __v_80: G = G::from_u64(127);
+    let __v_81: G = G::from_u64(82);
+    let __v_82: G = G::from_u64(14);
+    let __v_83: G = G::from_u64(81);
+    let __v_84: G = G::from_u64(140);
+    let __v_85: G = G::from_u64(104);
+    let __v_86: G = G::from_u64(5);
+    let __v_87: G = G::from_u64(155);
+    let __v_88: G = G::from_u64(171);
+    let __v_89: G = G::from_u64(217);
+    let __v_90: G = G::from_u64(131);
+    let __v_91: G = G::from_u64(31);
+    let __v_92: G = G::from_u64(25);
+    let __v_93: G = G::from_u64(205);
+    let __v_94: G = G::from_u64(224);
+    let __v_95: G = G::from_u64(91);
+    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(64);
+    let __v_105: G = G::from_u64(11);
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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_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, __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_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_106: G = __r_arr[0];
+    let __v_107: G = __r_arr[1];
+    let __v_108: G = __r_arr[2];
+    let __v_109: G = __r_arr[3];
+    let __v_110: G = __r_arr[4];
+    let __v_111: G = __r_arr[5];
+    let __v_112: G = __r_arr[6];
+    let __v_113: G = __r_arr[7];
+    let __v_114: G = __r_arr[8];
+    let __v_115: G = __r_arr[9];
+    let __v_116: G = __r_arr[10];
+    let __v_117: G = __r_arr[11];
+    let __v_118: G = __r_arr[12];
+    let __v_119: G = __r_arr[13];
+    let __v_120: G = __r_arr[14];
+    let __v_121: G = __r_arr[15];
+    let __v_122: G = __r_arr[16];
+    let __v_123: G = __r_arr[17];
+    let __v_124: G = __r_arr[18];
+    let __v_125: G = __r_arr[19];
+    let __v_126: G = __r_arr[20];
+    let __v_127: G = __r_arr[21];
+    let __v_128: G = __r_arr[22];
+    let __v_129: G = __r_arr[23];
+    let __v_130: G = __r_arr[24];
+    let __v_131: G = __r_arr[25];
+    let __v_132: G = __r_arr[26];
+    let __v_133: G = __r_arr[27];
+    let __v_134: G = __r_arr[28];
+    let __v_135: G = __r_arr[29];
+    let __v_136: G = __r_arr[30];
+    let __v_137: G = __r_arr[31];
+    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; 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_138: G = __r_arr[0];
+    let __v_139: G = __r_arr[1];
+    let __v_140: G = __r_arr[2];
+    let __v_141: G = __r_arr[3];
+    let __v_142: G = __r_arr[4];
+    let __v_143: G = __r_arr[5];
+    let __v_144: G = __r_arr[6];
+    let __v_145: G = __r_arr[7];
+    let __v_146: G = __r_arr[8];
+    let __v_147: G = __r_arr[9];
+    let __v_148: G = __r_arr[10];
+    let __v_149: G = __r_arr[11];
+    let __v_150: G = __r_arr[12];
+    let __v_151: G = __r_arr[13];
+    let __v_152: G = __r_arr[14];
+    let __v_153: G = __r_arr[15];
+    let __v_154: G = __r_arr[16];
+    let __v_155: G = __r_arr[17];
+    let __v_156: G = __r_arr[18];
+    let __v_157: G = __r_arr[19];
+    let __v_158: G = __r_arr[20];
+    let __v_159: G = __r_arr[21];
+    let __v_160: G = __r_arr[22];
+    let __v_161: G = __r_arr[23];
+    let __v_162: G = __r_arr[24];
+    let __v_163: G = __r_arr[25];
+    let __v_164: G = __r_arr[26];
+    let __v_165: G = __r_arr[27];
+    let __v_166: G = __r_arr[28];
+    let __v_167: G = __r_arr[29];
+    let __v_168: G = __r_arr[30];
+    let __v_169: G = __r_arr[31];
+    let __ret: [G; OUT_100] = [__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];
+    record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_101: usize = 64;
+const IN_101: usize = 64;
+const OUT_101: usize = 1;
+fn aiur_fn_101(
+  inp: [G; IN_101],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_101], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_64: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; 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_65: G = __r_arr[0];
+    let __v_66: G = (__v_64 - __v_65);
+    let __v_67: G = G::from_bool((__v_66 == G::ZERO));
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_68: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_69: G = __r_arr[0];
+    let __v_70: G = (__v_68 - __v_69);
+    let __v_71: G = G::from_bool((__v_70 == G::ZERO));
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_73: G = __r_arr[0];
+    let __v_74: G = (__v_72 - __v_73);
+    let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_76: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_77: G = __r_arr[0];
+    let __v_78: G = (__v_76 - __v_77);
+    let __v_79: G = G::from_bool((__v_78 == G::ZERO));
+    let __v_80: G = (__v_75 * __v_79);
+    let __v_81: G = (__v_71 * __v_80);
+    let __v_82: G = (__v_67 * __v_81);
+    let __ret: [G; OUT_101] = [__v_82];
+    record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_102: usize = 65;
+const IN_102: usize = 65;
+const OUT_102: usize = 32;
+fn aiur_fn_102(
+  inp: [G; IN_102],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_102], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__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, __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[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_65: G = __r_arr[0];
+        let __v_66: G = __r_arr[1];
+        let __v_67: G = __r_arr[2];
+        let __v_68: G = __r_arr[3];
+        let __v_69: G = __r_arr[4];
+        let __v_70: G = __r_arr[5];
+        let __v_71: G = __r_arr[6];
+        let __v_72: G = __r_arr[7];
+        let __v_73: G = __r_arr[8];
+        let __v_74: G = __r_arr[9];
+        let __v_75: G = __r_arr[10];
+        let __v_76: G = __r_arr[11];
+        let __v_77: G = __r_arr[12];
+        let __v_78: G = __r_arr[13];
+        let __v_79: G = __r_arr[14];
+        let __v_80: G = __r_arr[15];
+        let __v_81: G = __r_arr[16];
+        let __v_82: G = __r_arr[17];
+        let __v_83: G = __r_arr[18];
+        let __v_84: G = __r_arr[19];
+        let __v_85: G = __r_arr[20];
+        let __v_86: G = __r_arr[21];
+        let __v_87: G = __r_arr[22];
+        let __v_88: G = __r_arr[23];
+        let __v_89: G = __r_arr[24];
+        let __v_90: G = __r_arr[25];
+        let __v_91: G = __r_arr[26];
+        let __v_92: G = __r_arr[27];
+        let __v_93: G = __r_arr[28];
+        let __v_94: G = __r_arr[29];
+        let __v_95: G = __r_arr[30];
+        let __v_96: G = __r_arr[31];
+        let __ret: [G; OUT_102] = [__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];
+        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__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_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[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_65: G = __r_arr[0];
+        let __v_66: G = __r_arr[1];
+        let __v_67: G = __r_arr[2];
+        let __v_68: G = __r_arr[3];
+        let __v_69: G = __r_arr[4];
+        let __v_70: G = __r_arr[5];
+        let __v_71: G = __r_arr[6];
+        let __v_72: G = __r_arr[7];
+        let __v_73: G = __r_arr[8];
+        let __v_74: G = __r_arr[9];
+        let __v_75: G = __r_arr[10];
+        let __v_76: G = __r_arr[11];
+        let __v_77: G = __r_arr[12];
+        let __v_78: G = __r_arr[13];
+        let __v_79: G = __r_arr[14];
+        let __v_80: G = __r_arr[15];
+        let __v_81: G = __r_arr[16];
+        let __v_82: G = __r_arr[17];
+        let __v_83: G = __r_arr[18];
+        let __v_84: G = __r_arr[19];
+        let __v_85: G = __r_arr[20];
+        let __v_86: G = __r_arr[21];
+        let __v_87: G = __r_arr[22];
+        let __v_88: G = __r_arr[23];
+        let __v_89: G = __r_arr[24];
+        let __v_90: G = __r_arr[25];
+        let __v_91: G = __r_arr[26];
+        let __v_92: G = __r_arr[27];
+        let __v_93: G = __r_arr[28];
+        let __v_94: G = __r_arr[29];
+        let __v_95: G = __r_arr[30];
+        let __v_96: G = __r_arr[31];
+        let __ret: [G; OUT_102] = [__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];
+        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_103: usize = 2;
+const IN_103: usize = 2;
+const OUT_103: usize = 1;
+fn aiur_fn_103(
+  inp: [G; IN_103],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_103], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __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_103] = [__v_5];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = (__v_3 - __v_1);
+        let __v_6: G = G::from_bool((__v_5 == G::ZERO));
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_103] = [__v_7];
+            record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
+            let __ret: [G; OUT_103] = [__v_7];
+            record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_104: usize = 3;
+const IN_104: usize = 3;
+const OUT_104: usize = 1;
+fn aiur_fn_104(
+  inp: [G; IN_104],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_104], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = 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_104] = [__v_8];
+        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = (__v_7 - __v_2);
+            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __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 __ret: [G; OUT_104] = [__v_11];
+                record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                let __v_14: G = __loaded[3];
+                let __v_15: G = __loaded[4];
+                let __v_16: G = __loaded[5];
+                let __v_17: G = __loaded[6];
+                let __v_18: G = __loaded[7];
+                let __v_19: G = __loaded[8];
+                let __v_20: G = __loaded[9];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __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_21: G = __r_arr[0];
+                    let __ret: [G; OUT_104] = [__v_21];
+                    record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_21: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __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_22: G = __r_arr[0];
+                    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_104] = [__v_23];
+                    record.function_queries[104].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_105: usize = 2;
+const IN_105: usize = 2;
+const OUT_105: usize = 11;
+fn aiur_fn_105(
+  inp: [G; IN_105],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_105], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_12]; 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 __v_21: G = G::from_u64(1);
+        let __ret: [G; OUT_105] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_11, __v_1, __v_21];
+        record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = G::from_u64(0);
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = G::from_u64(0);
+            let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
+            record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_13, __v_14]; 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_15: G = __r_arr[0];
+            let __v_16: G = __r_arr[1];
+            let __v_17: G = __r_arr[2];
+            let __v_18: G = __r_arr[3];
+            let __v_19: G = __r_arr[4];
+            let __v_20: G = __r_arr[5];
+            let __v_21: G = __r_arr[6];
+            let __v_22: G = __r_arr[7];
+            let __v_23: G = __r_arr[8];
+            let __v_24: G = __r_arr[9];
+            let __v_25: G = __r_arr[10];
+            let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+            record.function_queries[105].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_106: usize = 6;
+const IN_106: usize = 6;
+const OUT_106: usize = 1;
+fn aiur_fn_106(
+  inp: [G; IN_106],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_106], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __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_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __v_8: G = __r_arr[2];
+    let __v_9: G = __r_arr[3];
+    let __v_10: G = __r_arr[4];
+    let __v_11: G = __r_arr[5];
+    let __v_12: G = __r_arr[6];
+    let __v_13: G = __r_arr[7];
+    let __v_14: G = __r_arr[8];
+    let __v_15: G = __r_arr[9];
+    let __v_16: G = __r_arr[10];
+    match __v_16.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_17: G = __loaded[0];
+        let __v_18: G = __loaded[1];
+        let __v_19: G = __loaded[2];
+        let __v_20: G = __loaded[3];
+        let __v_21: G = __loaded[4];
+        let __v_22: G = __loaded[5];
+        let __v_23: G = __loaded[6];
+        let __v_24: G = __loaded[7];
+        match __v_17.as_canonical_u64() {
+          0u64 => {
+            match __v_18.as_canonical_u64() {
+              0u64 => {
+                match __v_19.as_canonical_u64() {
+                  0u64 => {
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        match __v_21.as_canonical_u64() {
+                          0u64 => {
+                            match __v_22.as_canonical_u64() {
+                              0u64 => {
+                                match __v_23.as_canonical_u64() {
+                                  0u64 => {
+                                    match __v_24.as_canonical_u64() {
+                                      0u64 => {
+                                        let __v_25: G = G::from_u64(0);
+                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                        let __v_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];
+                                        let __v_38: G = __loaded[12];
+                                        let __v_39: G = __loaded[13];
+                                        let __v_40: G = __loaded[14];
+                                        let __v_41: G = __loaded[15];
+                                        let __v_42: G = __loaded[16];
+                                        let __v_43: G = __loaded[17];
+                                        let __v_44: G = __loaded[18];
+                                        let __v_45: G = __loaded[19];
+                                        let __v_46: G = __loaded[20];
+                                        let __v_47: G = __loaded[21];
+                                        let __v_48: G = __loaded[22];
+                                        let __v_49: G = __loaded[23];
+                                        let __v_50: G = __loaded[24];
+                                        let __v_51: G = __loaded[25];
+                                        let __v_52: G = __loaded[26];
+                                        let __v_53: G = __loaded[27];
+                                        let __v_54: G = __loaded[28];
+                                        let __v_55: G = __loaded[29];
+                                        let __v_56: G = __loaded[30];
+                                        let __v_57: G = __loaded[31];
+                                        let __v_58: G = G::from_u64(0);
+                                        let __v_59: G = G::from_u64(0);
+                                        let __v_60: G = G::from_u64(0);
+                                        let __v_61: G = G::from_u64(0);
+                                        let __v_62: G = G::from_u64(0);
+                                        let __v_63: G = G::from_u64(0);
+                                        let __v_64: G = G::from_u64(0);
+                                        let __v_65: G = G::from_u64(0);
+                                        let __v_66: G = G::from_u64(0);
+                                        let __v_67: G = G::from_u64(0);
+                                        let __v_68: G = G::from_u64(0);
+                                        let __v_69: G = G::from_u64(0);
+                                        let __v_70: G = G::from_u64(0);
+                                        let __v_71: G = G::from_u64(0);
+                                        let __v_72: G = G::from_u64(0);
+                                        let __v_73: G = G::from_u64(0);
+                                        let __v_74: G = G::from_u64(0);
+                                        let __v_75: G = G::from_u64(0);
+                                        let __v_76: G = G::from_u64(0);
+                                        let __v_77: G = G::from_u64(0);
+                                        let __v_78: G = G::from_u64(0);
+                                        let __v_79: G = G::from_u64(0);
+                                        let __v_80: G = G::from_u64(0);
+                                        let __v_81: G = G::from_u64(0);
+                                        let __v_82: G = G::from_u64(0);
+                                        let __v_83: G = G::from_u64(0);
+                                        let __v_84: G = G::from_u64(0);
+                                        let __v_85: G = G::from_u64(0);
+                                        let __v_86: G = G::from_u64(0);
+                                        let __v_87: G = G::from_u64(0);
+                                        let __v_88: G = G::from_u64(0);
+                                        let __v_89: G = G::from_u64(0);
+                                        let __v_90: G = G::from_u64(0);
+                                        let __v_91: G = G::from_u64(0);
+                                        let __v_92: G = G::from_u64(0);
+                                        let __v_93: G = G::from_u64(0);
+                                        let __v_94: G = G::from_u64(0);
+                                        let __v_95: G = G::from_u64(0);
+                                        let __v_96: G = G::from_u64(0);
+                                        let __v_97: G = G::from_u64(0);
+                                        let __v_98: G = G::from_u64(0);
+                                        let __v_99: G = G::from_u64(0);
+                                        let __v_100: G = G::from_u64(0);
+                                        let __v_101: G = G::from_u64(0);
+                                        let __v_102: G = G::from_u64(0);
+                                        let __v_103: G = G::from_u64(0);
+                                        let __v_104: G = G::from_u64(0);
+                                        let __v_105: G = G::from_u64(0);
+                                        let __v_106: G = G::from_u64(0);
+                                        let __v_107: G = G::from_u64(0);
+                                        let __v_108: G = G::from_u64(0);
+                                        let __v_109: G = G::from_u64(0);
+                                        let __v_110: G = G::from_u64(0);
+                                        let __v_111: G = G::from_u64(0);
+                                        let __v_112: G = G::from_u64(0);
+                                        let __v_113: G = G::from_u64(0);
+                                        let __v_114: G = G::from_u64(0);
+                                        let __v_115: G = G::from_u64(0);
+                                        let __v_116: G = G::from_u64(0);
+                                        let __v_117: G = G::from_u64(0);
+                                        let __v_118: G = G::from_u64(0);
+                                        let __v_119: G = G::from_u64(0);
+                                        let __v_120: G = G::from_u64(0);
+                                        let __v_121: G = G::from_u64(0);
+                                        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                        let __v_122: G = __loaded[0];
+                                        let __v_123: G = __loaded[1];
+                                        let __v_124: G = __loaded[2];
+                                        let __v_125: G = __loaded[3];
+                                        let __v_126: G = __loaded[4];
+                                        let __v_127: G = __loaded[5];
+                                        let __v_128: G = __loaded[6];
+                                        let __v_129: G = __loaded[7];
+                                        let __v_130: G = G::from_u64(0);
+                                        let __v_131: G = G::from_u64(11);
+                                        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131]; 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_132: G = __r_arr[0];
+                                        let __v_133: G = __r_arr[1];
+                                        let __v_134: G = __r_arr[2];
+                                        let __v_135: G = __r_arr[3];
+                                        let __v_136: G = __r_arr[4];
+                                        let __v_137: G = __r_arr[5];
+                                        let __v_138: G = __r_arr[6];
+                                        let __v_139: G = __r_arr[7];
+                                        let __v_140: G = __r_arr[8];
+                                        let __v_141: G = __r_arr[9];
+                                        let __v_142: G = __r_arr[10];
+                                        let __v_143: G = __r_arr[11];
+                                        let __v_144: G = __r_arr[12];
+                                        let __v_145: G = __r_arr[13];
+                                        let __v_146: G = __r_arr[14];
+                                        let __v_147: G = __r_arr[15];
+                                        let __v_148: G = __r_arr[16];
+                                        let __v_149: G = __r_arr[17];
+                                        let __v_150: G = __r_arr[18];
+                                        let __v_151: G = __r_arr[19];
+                                        let __v_152: G = __r_arr[20];
+                                        let __v_153: G = __r_arr[21];
+                                        let __v_154: G = __r_arr[22];
+                                        let __v_155: G = __r_arr[23];
+                                        let __v_156: G = __r_arr[24];
+                                        let __v_157: G = __r_arr[25];
+                                        let __v_158: G = __r_arr[26];
+                                        let __v_159: G = __r_arr[27];
+                                        let __v_160: G = __r_arr[28];
+                                        let __v_161: G = __r_arr[29];
+                                        let __v_162: G = __r_arr[30];
+                                        let __v_163: G = __r_arr[31];
+                                        let __v_164: G = { let __values: [G; 34] = [__v_25, __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_106] = [__v_164];
+                                        record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_106] = [__v_5];
+                                        record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_106] = [__v_5];
+                                    record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_106] = [__v_5];
+                                record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_106] = [__v_5];
+                            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_106] = [__v_5];
+                        record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_106] = [__v_5];
+                    record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_106] = [__v_5];
+                record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __ret: [G; OUT_106] = [__v_5];
+            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_14, __v_15]; 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_17: G = __r_arr[0];
+        let __v_18: G = __r_arr[1];
+        let __v_19: G = __r_arr[2];
+        let __v_20: G = __r_arr[3];
+        let __v_21: G = __r_arr[4];
+        let __v_22: G = __r_arr[5];
+        let __v_23: G = __r_arr[6];
+        let __v_24: G = __r_arr[7];
+        let __v_25: G = __r_arr[8];
+        let __v_26: G = __r_arr[9];
+        let __v_27: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_25, __v_26]; 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_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __v_30: G = __r_arr[2];
+        let __v_31: G = __r_arr[3];
+        let __v_32: G = __r_arr[4];
+        let __v_33: G = __r_arr[5];
+        let __v_34: G = __r_arr[6];
+        let __v_35: G = __r_arr[7];
+        let __v_36: G = __r_arr[8];
+        let __v_37: G = __r_arr[9];
+        let __v_38: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_36, __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_39: G = __r_arr[0];
+        let __v_40: G = __r_arr[1];
+        let __v_41: G = __r_arr[2];
+        let __v_42: G = __r_arr[3];
+        let __v_43: G = __r_arr[4];
+        let __v_44: G = __r_arr[5];
+        let __v_45: G = __r_arr[6];
+        let __v_46: G = __r_arr[7];
+        let __v_47: G = __r_arr[8];
+        let __v_48: G = __r_arr[9];
+        let __v_49: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48]; 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_50: G = __r_arr[0];
+        let __v_51: G = __r_arr[1];
+        let __v_52: G = __r_arr[2];
+        let __v_53: G = __r_arr[3];
+        let __v_54: G = __r_arr[4];
+        let __v_55: G = __r_arr[5];
+        let __v_56: G = __r_arr[6];
+        let __v_57: G = __r_arr[7];
+        let __v_58: G = __r_arr[8];
+        let __v_59: G = __r_arr[9];
+        let __v_60: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_58, __v_59]; 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_61: G = __r_arr[0];
+        let __v_62: G = __r_arr[1];
+        let __v_63: G = __r_arr[2];
+        let __v_64: G = __r_arr[3];
+        let __v_65: G = __r_arr[4];
+        let __v_66: G = __r_arr[5];
+        let __v_67: G = __r_arr[6];
+        let __v_68: G = __r_arr[7];
+        let __v_69: G = __r_arr[8];
+        let __v_70: G = __r_arr[9];
+        let __v_71: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_69, __v_70]; 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_72: G = __r_arr[0];
+        let __v_73: G = __r_arr[1];
+        let __v_74: G = __r_arr[2];
+        let __v_75: G = __r_arr[3];
+        let __v_76: G = __r_arr[4];
+        let __v_77: G = __r_arr[5];
+        let __v_78: G = __r_arr[6];
+        let __v_79: G = __r_arr[7];
+        let __v_80: G = __r_arr[8];
+        let __v_81: G = __r_arr[9];
+        let __v_82: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_80, __v_81]; 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_83: G = __r_arr[0];
+        let __v_84: G = __r_arr[1];
+        let __v_85: G = __r_arr[2];
+        let __v_86: G = __r_arr[3];
+        let __v_87: G = __r_arr[4];
+        let __v_88: G = __r_arr[5];
+        let __v_89: G = __r_arr[6];
+        let __v_90: G = __r_arr[7];
+        let __v_91: G = __r_arr[8];
+        let __v_92: G = __r_arr[9];
+        let __v_93: G = __r_arr[10];
+        let __v_94: G = G::from_u64(8);
+        let __v_95: G = (__v_82 + __v_93);
+        let __v_96: G = (__v_71 + __v_95);
+        let __v_97: G = (__v_60 + __v_96);
+        let __v_98: G = (__v_49 + __v_97);
+        let __v_99: G = (__v_38 + __v_98);
+        let __v_100: G = (__v_27 + __v_99);
+        let __v_101: G = (__v_16 + __v_100);
+        let __v_102: G = (__v_94 * __v_101);
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_103: G = __loaded[0];
+        let __v_104: G = __loaded[1];
+        let __v_105: G = __loaded[2];
+        let __v_106: G = __loaded[3];
+        let __v_107: G = __loaded[4];
+        let __v_108: G = __loaded[5];
+        let __v_109: G = __loaded[6];
+        let __v_110: G = __loaded[7];
+        let __v_111: G = __loaded[8];
+        let __v_112: G = __loaded[9];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() {
+  1u64 => {
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_113: G = __loaded[0];
+    let __v_114: G = __loaded[1];
+    let __v_115: G = __loaded[2];
+    match __v_113.as_canonical_u64() {
+      1u64 => {
+        let __v_116: G = G::from_u64(1);
+        break '__mc_0 [__v_116];
+      },
+      _ => {
+        let __v_116: G = G::from_u64(0);
+        break '__mc_0 [__v_116];
+      },
+    }
+  },
+  _ => {
+    let __v_113: G = G::from_u64(0);
+    break '__mc_0 [__v_113];
+  },
+}
+ };
+        let __v_113: G = __mc_out___mc_0[0];
+        let __v_114: G = G::from_u64(15);
+        let __v_115: G = (__v_2 - __v_114);
+        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
+        let __v_117: G = G::from_bool((__v_2 == G::ZERO));
+        let __v_118: G = (__v_113 * __v_116);
+        let __v_119: G = (__v_116 - __v_118);
+        let __v_120: G = (__v_113 + __v_119);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_121: G = __loaded[0];
+        let __v_122: G = __loaded[1];
+        let __v_123: G = __loaded[2];
+        let __v_124: G = __loaded[3];
+        let __v_125: G = __loaded[4];
+        let __v_126: G = __loaded[5];
+        let __v_127: G = __loaded[6];
+        let __v_128: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_129: G = __r_arr[0];
+        let __v_130: G = (__v_113 * __v_129);
+        let __v_131: G = G::from_u64(2);
+        let __v_132: G = (__v_131 * __v_120);
+        let __v_133: G = G::from_u64(8);
+        let __v_134: G = (__v_133 * __v_130);
+        let __v_135: G = (__v_132 + __v_134);
+        let __v_136: G = (__v_117 + __v_135);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_137: G = __loaded[0];
+        let __v_138: G = __loaded[1];
+        let __v_139: G = __loaded[2];
+        let __v_140: G = __loaded[3];
+        let __v_141: G = __loaded[4];
+        let __v_142: G = __loaded[5];
+        let __v_143: G = __loaded[6];
+        let __v_144: G = __loaded[7];
+        let __v_145: G = __loaded[8];
+        let __v_146: G = __loaded[9];
+        let __v_147: G = __loaded[10];
+        let __v_148: G = __loaded[11];
+        let __v_149: G = __loaded[12];
+        let __v_150: G = __loaded[13];
+        let __v_151: G = __loaded[14];
+        let __v_152: G = __loaded[15];
+        let __v_153: G = __loaded[16];
+        let __v_154: G = __loaded[17];
+        let __v_155: G = __loaded[18];
+        let __v_156: G = __loaded[19];
+        let __v_157: G = __loaded[20];
+        let __v_158: G = __loaded[21];
+        let __v_159: G = __loaded[22];
+        let __v_160: G = __loaded[23];
+        let __v_161: G = __loaded[24];
+        let __v_162: G = __loaded[25];
+        let __v_163: G = __loaded[26];
+        let __v_164: G = __loaded[27];
+        let __v_165: G = __loaded[28];
+        let __v_166: G = __loaded[29];
+        let __v_167: G = __loaded[30];
+        let __v_168: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_169: G = __loaded[0];
+        let __v_170: G = __loaded[1];
+        let __v_171: G = __loaded[2];
+        let __v_172: G = __loaded[3];
+        let __v_173: G = __loaded[4];
+        let __v_174: G = __loaded[5];
+        let __v_175: G = __loaded[6];
+        let __v_176: G = __loaded[7];
+        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_136]; 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_177: G = __r_arr[0];
+        let __v_178: G = __r_arr[1];
+        let __v_179: G = __r_arr[2];
+        let __v_180: G = __r_arr[3];
+        let __v_181: G = __r_arr[4];
+        let __v_182: G = __r_arr[5];
+        let __v_183: G = __r_arr[6];
+        let __v_184: G = __r_arr[7];
+        let __v_185: G = __r_arr[8];
+        let __v_186: G = __r_arr[9];
+        let __v_187: G = __r_arr[10];
+        let __v_188: G = __r_arr[11];
+        let __v_189: G = __r_arr[12];
+        let __v_190: G = __r_arr[13];
+        let __v_191: G = __r_arr[14];
+        let __v_192: G = __r_arr[15];
+        let __v_193: G = __r_arr[16];
+        let __v_194: G = __r_arr[17];
+        let __v_195: G = __r_arr[18];
+        let __v_196: G = __r_arr[19];
+        let __v_197: G = __r_arr[20];
+        let __v_198: G = __r_arr[21];
+        let __v_199: G = __r_arr[22];
+        let __v_200: G = __r_arr[23];
+        let __v_201: G = __r_arr[24];
+        let __v_202: G = __r_arr[25];
+        let __v_203: G = __r_arr[26];
+        let __v_204: G = __r_arr[27];
+        let __v_205: G = __r_arr[28];
+        let __v_206: G = __r_arr[29];
+        let __v_207: G = __r_arr[30];
+        let __v_208: G = __r_arr[31];
+        match __v_113.as_canonical_u64() {
+          1u64 => {
+            let __v_209: G = G::from_u64(0);
+            let __v_210: G = { let __values: [G; 34] = [__v_209, __v_5, __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, __v_204, __v_205, __v_206, __v_207, __v_208]; 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_106] = [__v_210];
+            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            match __v_116.as_canonical_u64() {
+              1u64 => {
+                let __v_209: G = G::from_u64(103);
+                let __v_210: G = G::from_u64(230);
+                let __v_211: G = G::from_u64(9);
+                let __v_212: G = G::from_u64(106);
+                let __v_213: G = G::from_u64(133);
+                let __v_214: G = G::from_u64(174);
+                let __v_215: G = G::from_u64(103);
+                let __v_216: G = G::from_u64(187);
+                let __v_217: G = G::from_u64(114);
+                let __v_218: G = G::from_u64(243);
+                let __v_219: G = G::from_u64(110);
+                let __v_220: G = G::from_u64(60);
+                let __v_221: G = G::from_u64(58);
+                let __v_222: G = G::from_u64(245);
+                let __v_223: G = G::from_u64(79);
+                let __v_224: G = G::from_u64(165);
+                let __v_225: G = G::from_u64(127);
+                let __v_226: G = G::from_u64(82);
+                let __v_227: G = G::from_u64(14);
+                let __v_228: G = G::from_u64(81);
+                let __v_229: G = G::from_u64(140);
+                let __v_230: G = G::from_u64(104);
+                let __v_231: G = G::from_u64(5);
+                let __v_232: G = G::from_u64(155);
+                let __v_233: G = G::from_u64(171);
+                let __v_234: G = G::from_u64(217);
+                let __v_235: G = G::from_u64(131);
+                let __v_236: G = G::from_u64(31);
+                let __v_237: G = G::from_u64(25);
+                let __v_238: G = G::from_u64(205);
+                let __v_239: G = G::from_u64(224);
+                let __v_240: G = G::from_u64(91);
+                let __v_241: G = G::from_u64(0);
+                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                let __v_242: G = __loaded[0];
+                let __v_243: G = __loaded[1];
+                let __v_244: G = __loaded[2];
+                let __v_245: G = __loaded[3];
+                let __v_246: G = __loaded[4];
+                let __v_247: G = __loaded[5];
+                let __v_248: G = __loaded[6];
+                let __v_249: G = __loaded[7];
+                let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
+                let __v_250: G = __r_arr[0];
+                let __v_251: G = __r_arr[1];
+                let __v_252: G = __r_arr[2];
+                let __v_253: G = __r_arr[3];
+                let __v_254: G = __r_arr[4];
+                let __v_255: G = __r_arr[5];
+                let __v_256: G = __r_arr[6];
+                let __v_257: G = __r_arr[7];
+                let __v_258: G = { let __values: [G; 8] = [__v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257]; 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_259: G = { let __values: [G; 32] = [__v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240]; 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_260: G = G::from_u64(0);
+                let __v_261: G = { let __values: [G; 34] = [__v_260, __v_5, __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, __v_204, __v_205, __v_206, __v_207, __v_208]; 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_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_241, __v_258, __v_259, __v_261]; 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_262: G = __r_arr[0];
+                let __ret: [G; OUT_106] = [__v_262];
+                record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_209: G = G::from_u64(1);
+                let __v_210: G = (__v_2 + __v_209);
+                let __v_211: G = { let __values: [G; 32] = [__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, __v_204, __v_205, __v_206, __v_207, __v_208]; 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_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_210, __v_3, __v_211, __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_212: G = __r_arr[0];
+                let __ret: [G; OUT_106] = [__v_212];
+                record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_107: usize = 1;
+const IN_107: usize = 1;
+const OUT_107: usize = 32;
+fn aiur_fn_107(
+  inp: [G; IN_107],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_107], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; 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_50: 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_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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].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 = __loaded[32];
+    let __v_84: G = __loaded[33];
+    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__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]; 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_85: G = __r_arr[0];
+    let __v_86: G = __r_arr[1];
+    let __v_87: G = __r_arr[2];
+    let __v_88: G = __r_arr[3];
+    let __v_89: G = __r_arr[4];
+    let __v_90: G = __r_arr[5];
+    let __v_91: G = __r_arr[6];
+    let __v_92: G = __r_arr[7];
+    let __v_93: G = __r_arr[8];
+    let __v_94: G = __r_arr[9];
+    let __v_95: G = __r_arr[10];
+    let __v_96: G = __r_arr[11];
+    let __v_97: G = __r_arr[12];
+    let __v_98: G = __r_arr[13];
+    let __v_99: G = __r_arr[14];
+    let __v_100: G = __r_arr[15];
+    let __v_101: G = __r_arr[16];
+    let __v_102: G = __r_arr[17];
+    let __v_103: G = __r_arr[18];
+    let __v_104: G = __r_arr[19];
+    let __v_105: G = __r_arr[20];
+    let __v_106: G = __r_arr[21];
+    let __v_107: G = __r_arr[22];
+    let __v_108: G = __r_arr[23];
+    let __v_109: G = __r_arr[24];
+    let __v_110: G = __r_arr[25];
+    let __v_111: G = __r_arr[26];
+    let __v_112: G = __r_arr[27];
+    let __v_113: G = __r_arr[28];
+    let __v_114: G = __r_arr[29];
+    let __v_115: G = __r_arr[30];
+    let __v_116: G = __r_arr[31];
+    let __ret: [G; OUT_107] = [__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];
+    record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_108: usize = 3;
+const IN_108: usize = 3;
+const OUT_108: usize = 32;
+fn aiur_fn_108(
+  inp: [G; IN_108],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_108], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __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_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __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 __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__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 __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_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 __v_40: G = __r_arr[4];
+    let __v_41: G = __r_arr[5];
+    let __v_42: G = __r_arr[6];
+    let __v_43: G = __r_arr[7];
+    let __v_44: G = __r_arr[8];
+    let __v_45: G = __r_arr[9];
+    let __v_46: G = __r_arr[10];
+    let __v_47: G = __r_arr[11];
+    let __v_48: G = __r_arr[12];
+    let __v_49: G = __r_arr[13];
+    let __v_50: G = __r_arr[14];
+    let __v_51: G = __r_arr[15];
+    let __v_52: G = __r_arr[16];
+    let __v_53: G = __r_arr[17];
+    let __v_54: G = __r_arr[18];
+    let __v_55: G = __r_arr[19];
+    let __v_56: G = __r_arr[20];
+    let __v_57: G = __r_arr[21];
+    let __v_58: G = __r_arr[22];
+    let __v_59: G = __r_arr[23];
+    let __v_60: G = __r_arr[24];
+    let __v_61: G = __r_arr[25];
+    let __v_62: G = __r_arr[26];
+    let __v_63: G = __r_arr[27];
+    let __v_64: G = __r_arr[28];
+    let __v_65: G = __r_arr[29];
+    let __v_66: G = __r_arr[30];
+    let __v_67: G = __r_arr[31];
+    let __ret: [G; OUT_108] = [__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];
+    record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_109: usize = 35;
+const IN_109: usize = 35;
+const OUT_109: usize = 32;
+fn aiur_fn_109(
+  inp: [G; IN_109],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_109], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __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 __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __v_2]; 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_35: G = __r_arr[0];
+    match __v_35.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_109] = [__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];
+        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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_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 __v_40: G = __r_arr[4];
+        let __v_41: G = __r_arr[5];
+        let __v_42: G = __r_arr[6];
+        let __v_43: G = __r_arr[7];
+        let __v_44: G = __r_arr[8];
+        let __v_45: G = __r_arr[9];
+        let __v_46: G = __r_arr[10];
+        let __v_47: G = __r_arr[11];
+        let __v_48: G = __r_arr[12];
+        let __v_49: G = __r_arr[13];
+        let __v_50: G = __r_arr[14];
+        let __v_51: G = __r_arr[15];
+        let __v_52: G = __r_arr[16];
+        let __v_53: G = __r_arr[17];
+        let __v_54: G = __r_arr[18];
+        let __v_55: G = __r_arr[19];
+        let __v_56: G = __r_arr[20];
+        let __v_57: G = __r_arr[21];
+        let __v_58: G = __r_arr[22];
+        let __v_59: G = __r_arr[23];
+        let __v_60: G = __r_arr[24];
+        let __v_61: G = __r_arr[25];
+        let __v_62: G = __r_arr[26];
+        let __v_63: G = __r_arr[27];
+        let __v_64: G = __r_arr[28];
+        let __v_65: G = __r_arr[29];
+        let __v_66: G = __r_arr[30];
+        let __v_67: G = __r_arr[31];
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__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_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]; 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_68: G = __r_arr[0];
+        let __v_69: G = __r_arr[1];
+        let __v_70: G = __r_arr[2];
+        let __v_71: G = __r_arr[3];
+        let __v_72: G = __r_arr[4];
+        let __v_73: G = __r_arr[5];
+        let __v_74: G = __r_arr[6];
+        let __v_75: G = __r_arr[7];
+        let __v_76: G = __r_arr[8];
+        let __v_77: G = __r_arr[9];
+        let __v_78: G = __r_arr[10];
+        let __v_79: G = __r_arr[11];
+        let __v_80: G = __r_arr[12];
+        let __v_81: G = __r_arr[13];
+        let __v_82: G = __r_arr[14];
+        let __v_83: G = __r_arr[15];
+        let __v_84: G = __r_arr[16];
+        let __v_85: G = __r_arr[17];
+        let __v_86: G = __r_arr[18];
+        let __v_87: G = __r_arr[19];
+        let __v_88: G = __r_arr[20];
+        let __v_89: G = __r_arr[21];
+        let __v_90: G = __r_arr[22];
+        let __v_91: G = __r_arr[23];
+        let __v_92: G = __r_arr[24];
+        let __v_93: G = __r_arr[25];
+        let __v_94: G = __r_arr[26];
+        let __v_95: G = __r_arr[27];
+        let __v_96: G = __r_arr[28];
+        let __v_97: G = __r_arr[29];
+        let __v_98: G = __r_arr[30];
+        let __v_99: G = __r_arr[31];
+        let __ret: [G; OUT_109] = [__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];
+        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_110: usize = 1;
+const IN_110: usize = 1;
+const OUT_110: usize = 1;
+fn aiur_fn_110(
+  inp: [G; IN_110],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_110], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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_110] = [__v_4];
+        record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(2);
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_3]; 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_5: G = __r_arr[0];
+        let __v_6: G = (__v_4 * __v_5);
+        let __v_7: G = (__v_2 + __v_6);
+        let __ret: [G; OUT_110] = [__v_7];
+        record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_111: usize = 37;
+const IN_111: usize = 37;
+const OUT_111: usize = 33;
+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];
+    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 __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].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 __v_55: G = __loaded[18];
+    let __v_56: G = __loaded[19];
+    let __v_57: G = __loaded[20];
+    let __v_58: G = __loaded[21];
+    let __v_59: G = __loaded[22];
+    let __v_60: G = __loaded[23];
+    let __v_61: G = __loaded[24];
+    let __v_62: G = __loaded[25];
+    let __v_63: G = __loaded[26];
+    let __v_64: G = __loaded[27];
+    let __v_65: G = __loaded[28];
+    let __v_66: G = __loaded[29];
+    let __v_67: G = __loaded[30];
+    let __v_68: G = __loaded[31];
+    let __v_69: G = __loaded[32];
+    let __v_70: G = __loaded[33];
+    match __v_37.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_35]; 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_71: G = __r_arr[0];
+        let __ret: [G; OUT_111] = [__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_71];
+        record.function_queries[111].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_35.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_71: G = __loaded[0];
+        let __v_72: G = __loaded[1];
+        let __v_73: G = __loaded[2];
+        match __v_71.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_72, __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_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]; 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_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 __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_32, __v_33, __v_36, __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]; 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_106: G = __r_arr[0];
+            let __v_107: G = __r_arr[1];
+            let __v_108: G = __r_arr[2];
+            let __v_109: G = __r_arr[3];
+            let __v_110: G = __r_arr[4];
+            let __v_111: G = __r_arr[5];
+            let __v_112: G = __r_arr[6];
+            let __v_113: G = __r_arr[7];
+            let __v_114: G = __r_arr[8];
+            let __v_115: G = __r_arr[9];
+            let __v_116: G = __r_arr[10];
+            let __v_117: G = __r_arr[11];
+            let __v_118: G = __r_arr[12];
+            let __v_119: G = __r_arr[13];
+            let __v_120: G = __r_arr[14];
+            let __v_121: G = __r_arr[15];
+            let __v_122: G = __r_arr[16];
+            let __v_123: G = __r_arr[17];
+            let __v_124: G = __r_arr[18];
+            let __v_125: G = __r_arr[19];
+            let __v_126: G = __r_arr[20];
+            let __v_127: G = __r_arr[21];
+            let __v_128: G = __r_arr[22];
+            let __v_129: G = __r_arr[23];
+            let __v_130: G = __r_arr[24];
+            let __v_131: G = __r_arr[25];
+            let __v_132: G = __r_arr[26];
+            let __v_133: G = __r_arr[27];
+            let __v_134: G = __r_arr[28];
+            let __v_135: G = __r_arr[29];
+            let __v_136: G = __r_arr[30];
+            let __v_137: G = __r_arr[31];
+            let __v_138: G = G::from_u64(1);
+            let __v_139: G = (__v_36 - __v_138);
+            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_32, __v_33, __v_70, __v_73, __v_139]; 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_140: G = __r_arr[0];
+            let __v_141: G = __r_arr[1];
+            let __v_142: G = __r_arr[2];
+            let __v_143: G = __r_arr[3];
+            let __v_144: G = __r_arr[4];
+            let __v_145: G = __r_arr[5];
+            let __v_146: G = __r_arr[6];
+            let __v_147: G = __r_arr[7];
+            let __v_148: G = __r_arr[8];
+            let __v_149: G = __r_arr[9];
+            let __v_150: G = __r_arr[10];
+            let __v_151: G = __r_arr[11];
+            let __v_152: G = __r_arr[12];
+            let __v_153: G = __r_arr[13];
+            let __v_154: G = __r_arr[14];
+            let __v_155: G = __r_arr[15];
+            let __v_156: G = __r_arr[16];
+            let __v_157: G = __r_arr[17];
+            let __v_158: G = __r_arr[18];
+            let __v_159: G = __r_arr[19];
+            let __v_160: G = __r_arr[20];
+            let __v_161: G = __r_arr[21];
+            let __v_162: G = __r_arr[22];
+            let __v_163: G = __r_arr[23];
+            let __v_164: G = __r_arr[24];
+            let __v_165: G = __r_arr[25];
+            let __v_166: G = __r_arr[26];
+            let __v_167: G = __r_arr[27];
+            let __v_168: G = __r_arr[28];
+            let __v_169: G = __r_arr[29];
+            let __v_170: G = __r_arr[30];
+            let __v_171: G = __r_arr[31];
+            let __v_172: G = __r_arr[32];
+            let __ret: [G; OUT_111] = [__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];
+            record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_71.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_112: usize = 5;
+const IN_112: usize = 5;
+const OUT_112: usize = 33;
+fn aiur_fn_112(
+  inp: [G; IN_112],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_112], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_4]; 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_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 = G::from_u64(1);
+    let __v_38: G = (__v_4 - __v_37);
+    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __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_0, __v_1, __v_3, __v_2, __v_38]; 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_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __v_41: G = __r_arr[2];
+    let __v_42: G = __r_arr[3];
+    let __v_43: G = __r_arr[4];
+    let __v_44: G = __r_arr[5];
+    let __v_45: G = __r_arr[6];
+    let __v_46: G = __r_arr[7];
+    let __v_47: G = __r_arr[8];
+    let __v_48: G = __r_arr[9];
+    let __v_49: G = __r_arr[10];
+    let __v_50: G = __r_arr[11];
+    let __v_51: G = __r_arr[12];
+    let __v_52: G = __r_arr[13];
+    let __v_53: G = __r_arr[14];
+    let __v_54: G = __r_arr[15];
+    let __v_55: G = __r_arr[16];
+    let __v_56: G = __r_arr[17];
+    let __v_57: G = __r_arr[18];
+    let __v_58: G = __r_arr[19];
+    let __v_59: G = __r_arr[20];
+    let __v_60: G = __r_arr[21];
+    let __v_61: G = __r_arr[22];
+    let __v_62: G = __r_arr[23];
+    let __v_63: G = __r_arr[24];
+    let __v_64: G = __r_arr[25];
+    let __v_65: G = __r_arr[26];
+    let __v_66: G = __r_arr[27];
+    let __v_67: G = __r_arr[28];
+    let __v_68: G = __r_arr[29];
+    let __v_69: G = __r_arr[30];
+    let __v_70: G = __r_arr[31];
+    let __v_71: G = __r_arr[32];
+    let __ret: [G; OUT_112] = [__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];
+    record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_113: usize = 6;
+const IN_113: usize = 6;
+const OUT_113: usize = 1;
+fn aiur_fn_113(
+  inp: [G; IN_113],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_113], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __v_8: G = __r_arr[2];
+    let __v_9: G = __r_arr[3];
+    let __v_10: G = __r_arr[4];
+    let __v_11: G = __r_arr[5];
+    let __v_12: G = __r_arr[6];
+    let __v_13: G = __r_arr[7];
+    let __v_14: G = __r_arr[8];
+    let __v_15: G = __r_arr[9];
+    let __v_16: G = __r_arr[10];
+    let __v_17: G = __r_arr[11];
+    let __v_18: G = __r_arr[12];
+    let __v_19: G = __r_arr[13];
+    let __v_20: G = __r_arr[14];
+    let __v_21: G = __r_arr[15];
+    let __v_22: G = __r_arr[16];
+    let __v_23: G = __r_arr[17];
+    let __v_24: G = __r_arr[18];
+    let __v_25: G = __r_arr[19];
+    let __v_26: G = __r_arr[20];
+    let __v_27: G = __r_arr[21];
+    let __v_28: G = __r_arr[22];
+    let __v_29: G = __r_arr[23];
+    let __v_30: G = __r_arr[24];
+    let __v_31: G = __r_arr[25];
+    let __v_32: G = __r_arr[26];
+    let __v_33: G = __r_arr[27];
+    let __v_34: G = __r_arr[28];
+    let __v_35: G = __r_arr[29];
+    let __v_36: G = __r_arr[30];
+    let __v_37: G = __r_arr[31];
+    let __v_38: G = __r_arr[32];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_38]; 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_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __v_41: G = __r_arr[2];
+    let __v_42: G = __r_arr[3];
+    let __v_43: G = __r_arr[4];
+    let __v_44: G = __r_arr[5];
+    let __v_45: G = __r_arr[6];
+    let __v_46: G = __r_arr[7];
+    let __v_47: G = __r_arr[8];
+    let __v_48: G = __r_arr[9];
+    let __v_49: G = __r_arr[10];
+    let __v_50: G = __r_arr[11];
+    let __v_51: G = __r_arr[12];
+    let __v_52: G = __r_arr[13];
+    let __v_53: G = __r_arr[14];
+    let __v_54: G = __r_arr[15];
+    let __v_55: G = __r_arr[16];
+    let __v_56: G = __r_arr[17];
+    let __v_57: G = __r_arr[18];
+    let __v_58: G = __r_arr[19];
+    let __v_59: G = __r_arr[20];
+    let __v_60: G = __r_arr[21];
+    let __v_61: G = __r_arr[22];
+    let __v_62: G = __r_arr[23];
+    let __v_63: G = __r_arr[24];
+    let __v_64: G = __r_arr[25];
+    let __v_65: G = __r_arr[26];
+    let __v_66: G = __r_arr[27];
+    let __v_67: G = __r_arr[28];
+    let __v_68: G = __r_arr[29];
+    let __v_69: G = __r_arr[30];
+    let __v_70: G = __r_arr[31];
+    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__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_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]; 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_71: G = __r_arr[0];
+    let __ret: [G; OUT_113] = [__v_71];
+    record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_114: usize = 2;
+const IN_114: usize = 2;
+const OUT_114: usize = 1;
+fn aiur_fn_114(
+  inp: [G; IN_114],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_114], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __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_114] = [__v_1];
+        record.function_queries[114].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_114] = { let __args: [G; IN_114] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
+        let __ret: [G; OUT_114] = [__v_7];
+        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_115], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_115] = [__v_5];
+        record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_0]; 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_4]; 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_6: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_115] = [__v_6];
+            record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_0, __v_6]; 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_7: G = __r_arr[0];
+            let __ret: [G; OUT_115] = [__v_7];
+            record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_116: usize = 8;
+const IN_116: usize = 8;
+const OUT_116: usize = 2;
+fn aiur_fn_116(
+  inp: [G; IN_116],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_116], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(1);
+    let __v_9: G = (__v_1 + __v_8);
+    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_9]; 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_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_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 __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10, __v_14]; 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 __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_15, __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_16: G = __r_arr[0];
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_4, __v_5, __v_6, __v_7]; 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 __v_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __v_19: G = G::from_u64(2);
+    let __v_20: G = G::from_u64(0);
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_17, __v_18, __v_19, __v_20]; 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_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_4, __v_5, __v_6, __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_23: G = __r_arr[0];
+    let __v_24: G = __r_arr[1];
+    let __v_25: G = G::from_u64(0);
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_23, __v_24, __v_16, __v_25]; 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_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_2, __v_3, __v_26, __v_27]; 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_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_21, __v_22, __v_28, __v_29]; 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 __v_30: G = __r_arr[0];
+    let __v_31: G = __r_arr[1];
+    let __ret: [G; OUT_116] = [__v_30, __v_31];
+    record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_117: usize = 2;
+const IN_117: usize = 2;
+const OUT_117: usize = 1;
+fn aiur_fn_117(
+  inp: [G; IN_117],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_117], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(7);
+    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_1]; 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_3: G = __r_arr[0];
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_6]; 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_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_7]; 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_8: G = __r_arr[0];
+    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __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_9: G = __r_arr[0];
+    let __ret: [G; OUT_117] = [__v_9];
+    record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_118: usize = 1;
+const IN_118: usize = 1;
+const OUT_118: usize = 1;
+fn aiur_fn_118(
+  inp: [G; IN_118],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_118], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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; 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_118] = [__v_13];
+        record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_11: 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]; 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; 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_13: G = __r_arr[0];
+        let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __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_118] = [__v_14];
+        record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_119: usize = 10;
+const IN_119: usize = 10;
+const OUT_119: usize = 4;
+fn aiur_fn_119(
+  inp: [G; IN_119],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_119], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    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_119] = [__v_6, __v_7, __v_8, __v_9];
+        record.function_queries[119].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_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() {
+          0u64 => {
+            let __v_17: G = G::from_u64(0);
+            let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_14, __v_15, __v_11, __v_17]; 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_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_8, __v_9, __v_18, __v_19]; 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_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_20, __v_21, __v_2, __v_3]; 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_22: G = __r_arr[0];
+            let __v_23: G = __r_arr[1];
+            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_22, __v_23]; 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 __v_24: G = __r_arr[0];
+            let __v_25: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_8, __v_9, __v_4, __v_5]; 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_26: G = __r_arr[0];
+            let __v_27: G = __r_arr[1];
+            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12, __v_16, __v_2, __v_3, __v_4, __v_5, __v_24, __v_25, __v_26, __v_27]; 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 __ret: [G; OUT_119] = [__v_28, __v_29, __v_30, __v_31];
+            record.function_queries[119].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_120: usize = 2;
+const IN_120: usize = 2;
+const OUT_120: usize = 1;
+fn aiur_fn_120(
+  inp: [G; IN_120],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_120], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 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_120] = [__v_1];
+        record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3]; 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = __r_arr[2];
+        let __v_9: G = __r_arr[3];
+        let __v_10: G = __r_arr[4];
+        let __v_11: G = __r_arr[5];
+        let __v_12: G = __r_arr[6];
+        let __v_13: G = __r_arr[7];
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_4]; 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_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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __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_22: G = __r_arr[0];
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_14, __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[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_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_23]; 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_24: G = __r_arr[0];
+        let __ret: [G; OUT_120] = [__v_24];
+        record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_121: usize = 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; 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_121] = [__v_1];
+        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_5]; 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 __ret: [G; OUT_121] = [__v_6];
+        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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; 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_122] = [__v_1];
+        record.function_queries[122].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 __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __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_122] = [__v_6];
+        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_123: usize = 3;
+const IN_123: usize = 3;
+const OUT_123: usize = 1;
+fn aiur_fn_123(
+  inp: [G; IN_123],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_123], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_123] = [__v_2];
+        record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_2]; 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_3: G = __r_arr[0];
+        let __ret: [G; OUT_123] = [__v_3];
+        record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_124: usize = 2;
+const IN_124: usize = 2;
+const OUT_124: usize = 1;
+fn aiur_fn_124(
+  inp: [G; IN_124],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_124], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __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_124] = [__v_0];
+        record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __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_14: G = __r_arr[0];
+        let __ret: [G; OUT_124] = [__v_14];
+        record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_125: usize = 10;
+const IN_125: usize = 10;
+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_125], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    match __v_9.as_canonical_u64() {
+      0u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_125] = [__v_0, __v_12];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__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[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_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_162] = { let __args: [G; IN_162] = [__v_10, __v_13, __v_9]; 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_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __v_16: G = __r_arr[2];
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_14]; 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_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() });
+        }
+        let __ret: [G; OUT_125] = [__v_15, __v_16];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_126: usize = 4;
+const IN_126: usize = 4;
+const OUT_126: usize = 2;
+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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_126] = [__v_9, __v_0];
+        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        let __v_13: G = __loaded[6];
+        let __v_14: G = __loaded[7];
+        let __v_15: G = __loaded[8];
+        let __v_16: G = __loaded[9];
+        match __v_7.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_5]; 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_17: G = __r_arr[0];
+            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_18, __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_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __v_22: G = __r_arr[2];
+            let __v_23: G = __r_arr[3];
+            let __v_24: G = __r_arr[4];
+            let __v_25: G = __r_arr[5];
+            let __v_26: G = __r_arr[6];
+            let __v_27: G = __r_arr[7];
+            let __v_28: G = __r_arr[8];
+            let __v_29: G = __r_arr[9];
+            let __v_30: G = __r_arr[10];
+            let __v_31: G = __r_arr[11];
+            let __v_32: G = __r_arr[12];
+            let __v_33: G = __r_arr[13];
+            let __v_34: G = __r_arr[14];
+            let __v_35: G = __r_arr[15];
+            let __v_36: G = __r_arr[16];
+            let __v_37: G = __r_arr[17];
+            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_36, __v_6, __v_16, __v_3]; 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_38: G = __r_arr[0];
+            let __v_39: G = __r_arr[1];
+            let __v_40: G = G::from_u64(0);
+            let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_41: G = __r_arr[0];
+            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]; 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_42: G = __r_arr[0];
+            let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __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_126] = [__v_43, __v_39];
+            record.function_queries[126].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_127: usize = 2;
+const IN_127: usize = 2;
+const OUT_127: usize = 1;
+fn aiur_fn_127(
+  inp: [G; IN_127],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_127], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_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_127] = [__v_4];
+        record.function_queries[127].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_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; 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_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_127] = [__v_6];
+        record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_128: usize = 5;
+const IN_128: usize = 5;
+const OUT_128: usize = 1;
+fn aiur_fn_128(
+  inp: [G; IN_128],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_128], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_128] = [__v_5];
+        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __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_5: G = __r_arr[0];
+        let __v_6: G = (__v_1 - __v_4);
+        let __v_7: G = (__v_5 + __v_6);
+        let __v_8: G = G::from_bool((__v_7 == G::ZERO));
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_u64(1);
+            let __ret: [G; OUT_128] = [__v_9];
+            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_2 - __v_9);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 + __v_11);
+            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_10, __v_12, __v_4]; 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_13: G = __r_arr[0];
+            let __ret: [G; OUT_128] = [__v_13];
+            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_129: usize = 4;
+const IN_129: usize = 4;
+const OUT_129: usize = 1;
+fn aiur_fn_129(
+  inp: [G; IN_129],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_129], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_129] = [__v_6];
+        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_4, __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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_3 - __v_6);
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_7]; 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_8: G = __r_arr[0];
+            let __ret: [G; OUT_129] = [__v_8];
+            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 - __v_11);
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_12]; 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_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_129] = [__v_14];
+            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_130: usize = 8;
+const IN_130: usize = 8;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_130], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    let __v_11: G = __loaded[3];
+    let __v_12: G = __loaded[4];
+    let __v_13: G = __loaded[5];
+    let __v_14: G = __loaded[6];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __v_15: G = G::from_u64(1);
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_130] = [__v_17];
+        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_9.as_canonical_u64() {
+          _ => {
+            let __v_15: G = (__v_9 - __v_1);
+            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+            match __v_16.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_12, __v_13, __v_10, __v_11]; 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_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 = G::from_u64(0);
+                let __v_22: G = { let __values: [G; 7] = [__v_21, __v_9, __v_19, __v_20, __v_17, __v_18, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_130] = [__v_22];
+                record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_17: G = G::from_u64(0);
+                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_18: G = __r_arr[0];
+                let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_130] = [__v_19];
+                record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_131: usize = 2;
+const IN_131: usize = 2;
+const OUT_131: usize = 1;
+fn aiur_fn_131(
+  inp: [G; IN_131],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_131], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(1);
+        let __ret: [G; OUT_131] = [__v_9];
+        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_9: G = (__v_3 - __v_1);
+            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+            match __v_10.as_canonical_u64() {
+              1u64 => {
+                let __v_11: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(0);
+                let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_6, __v_7, __v_11, __v_12]; 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_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() });
+                }
+                let __v_15: G = G::from_u64(1);
+                let __ret: [G; OUT_131] = [__v_15];
+                record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_8, __v_1]; 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_11: G = __r_arr[0];
+                let __ret: [G; OUT_131] = [__v_11];
+                record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_132: usize = 2;
+const IN_132: usize = 2;
+const OUT_132: usize = 1;
+fn aiur_fn_132(
+  inp: [G; IN_132],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_132], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_132] = [__v_2];
+        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_132] = [__v_2];
+        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_133: usize = 10;
+const IN_133: usize = 10;
+const OUT_133: usize = 1;
+fn aiur_fn_133(
+  inp: [G; IN_133],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_133], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = (__v_3 - __v_1);
+    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_2, __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 __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_11, __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_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(0);
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_4, __v_5, __v_12, __v_13]; 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_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_14, __v_15]; 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 __v_17: G = __r_arr[1];
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6]; 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_18: G = __r_arr[0];
+    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__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_19: G = __r_arr[0];
+    let __v_20: G = (__v_18 - __v_19);
+    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() });
+    }
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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[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 __ret: [G; OUT_133] = [__v_23];
+    record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_134: usize = 11;
+const IN_134: usize = 11;
+const OUT_134: usize = 1;
+fn aiur_fn_134(
+  inp: [G; IN_134],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_134], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    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_210] = { let __args: [G; IN_210] = [__v_8, __v_11]; 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 __v_13: G = G::from_u64(1);
+    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_8, __v_13]; 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_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_4]; 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_15: G = __r_arr[0];
+    let __v_16: G = G::from_u64(0);
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_5, __v_6, __v_15, __v_16]; 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_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_19: G = __r_arr[0];
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_19, __v_3, __v_1, __v_2, __v_17, __v_18, __v_7, __v_14, __v_9, __v_10]; 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 __ret: [G; OUT_134] = [__v_20];
+    record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_135: usize = 13;
+const IN_135: usize = 13;
+const OUT_135: usize = 1;
+fn aiur_fn_135(
+  inp: [G; IN_135],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_135], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_135] = [__v_0];
+        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_6, __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_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_9, __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_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; 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_16: G = __r_arr[0];
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_10, __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_17: G = __r_arr[0];
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_16, __v_17, __v_11, __v_12]; 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_18: G = __r_arr[0];
+        let __v_19: G = G::from_u64(1);
+        let __v_20: G = (__v_4 + __v_19);
+        let __v_21: G = G::from_u64(1);
+        let __v_22: G = (__v_5 - __v_21);
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_18, __v_1, __v_2, __v_3, __v_20, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_23: G = __r_arr[0];
+        let __ret: [G; OUT_135] = [__v_23];
+        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_136: usize = 12;
+const IN_136: usize = 12;
+const OUT_136: usize = 2;
+fn aiur_fn_136(
+  inp: [G; IN_136],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_136], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    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_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_136] = [__v_0, __v_4];
+        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_8, __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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; 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_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_9, __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_14: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_14, __v_15]; 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_16: G = __r_arr[0];
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_3, __v_1, __v_2, __v_6, __v_7, __v_13, __v_16, __v_10, __v_11]; 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_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(1);
+        let __v_19: G = (__v_4 + __v_18);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_5 - __v_20);
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __ret: [G; OUT_136] = [__v_22, __v_23];
+        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_137: usize = 15;
+const IN_137: usize = 15;
+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];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_137] = [__v_0];
+        record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7, __v_4]; 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 = __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];
+        match __v_15.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_22]; 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_27: G = __r_arr[0];
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_8, __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_28: G = __r_arr[0];
+            let __v_29: G = (__v_28 + __v_3);
+            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_29, __v_6, __v_27, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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_30: G = __r_arr[0];
+            let __v_31: G = __r_arr[1];
+            let __v_32: G = G::from_u64(1);
+            let __v_33: G = (__v_4 + __v_32);
+            let __v_34: G = G::from_u64(1);
+            let __v_35: G = (__v_5 - __v_34);
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_30, __v_1, __v_2, __v_3, __v_33, __v_35, __v_31, __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[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_36: G = __r_arr[0];
+            let __ret: [G; OUT_137] = [__v_36];
+            record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_138: usize = 15;
+const IN_138: usize = 15;
+const OUT_138: usize = 1;
+fn aiur_fn_138(
+  inp: [G; IN_138],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_138], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_138] = [__v_0];
+        record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        match __v_15.as_canonical_u64() {
+          0u64 => {
+            let __v_17: G = G::from_u64(1);
+            let __v_18: G = (__v_4 + __v_17);
+            let __v_19: G = G::from_u64(1);
+            let __v_20: G = (__v_5 - __v_19);
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_21: G = __r_arr[0];
+            let __ret: [G; OUT_138] = [__v_21];
+            record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __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_17: G = __r_arr[0];
+            let __v_18: G = (__v_17 + __v_3);
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_11, __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_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_19]; 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_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_12, __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_21: G = __r_arr[0];
+            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_20, __v_21, __v_13, __v_14]; 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 __v_23: G = G::from_u64(1);
+            let __v_24: G = (__v_4 + __v_23);
+            let __v_25: G = G::from_u64(1);
+            let __v_26: G = (__v_5 - __v_25);
+            let __v_27: G = G::from_u64(1);
+            let __v_28: G = (__v_6 + __v_27);
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_22, __v_1, __v_2, __v_3, __v_24, __v_26, __v_28, __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[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_29: G = __r_arr[0];
+            let __ret: [G; OUT_138] = [__v_29];
+            record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_139: usize = 15;
+const IN_139: usize = 15;
+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 __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_139] = [__v_0];
+        record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_15: G = G::from_u64(3);
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        match __v_16.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_16]; 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_18: G = __r_arr[0];
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4]; 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 __v_20: G = (__v_18 - __v_19);
+            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() });
+            }
+            let __v_23: G = G::from_u64(0);
+            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_6, __v_10, __v_5, __v_7, __v_23]; 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_24: G = __r_arr[0];
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2, __v_16, __v_24, __v_8, __v_17, __v_9]; 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 __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_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_8, __v_9, __v_10, __v_27, __v_7, __v_28, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_29: G = __r_arr[0];
+            let __ret: [G; OUT_139] = [__v_29];
+            record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_140: usize = 4;
+const IN_140: usize = 4;
+const OUT_140: usize = 1;
+fn aiur_fn_140(
+  inp: [G; IN_140],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_140], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    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_140] = [__v_6];
+        record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __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_5: G = __r_arr[0];
+        let __v_6: G = (__v_5 + __v_1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 - __v_7);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 + __v_9);
+        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_8, __v_10]; 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_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_140] = [__v_12];
+        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 = 1;
+fn aiur_fn_141(
+  inp: [G; IN_141],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_141], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_141] = [__v_7];
+        record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_4]; 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_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];
+        match __v_5.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_1, __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_17: G = __r_arr[0];
+            let __v_18: G = (__v_17 + __v_2);
+            let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_12]; 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_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_19]; 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_20: G = __r_arr[0];
+            let __v_21: G = G::from_u64(1);
+            let __v_22: G = (__v_3 - __v_21);
+            let __v_23: G = G::from_u64(1);
+            let __v_24: G = (__v_4 + __v_23);
+            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_22, __v_24]; 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_25: G = __r_arr[0];
+            let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_20, __v_25]; 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_26: G = __r_arr[0];
+            let __ret: [G; OUT_141] = [__v_26];
+            record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_142: usize = 5;
+const IN_142: usize = 5;
+const OUT_142: usize = 1;
+fn aiur_fn_142(
+  inp: [G; IN_142],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_142], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_142] = [__v_7];
+        record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_3 - __v_7);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_4 + __v_9);
+            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_8, __v_10]; 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_11: G = __r_arr[0];
+            let __ret: [G; OUT_142] = [__v_11];
+            record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __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_8: G = __r_arr[0];
+            let __v_9: G = (__v_8 + __v_1);
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_3 - __v_10);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = (__v_4 + __v_12);
+            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_2, __v_11, __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 __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_142] = [__v_15];
+            record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_143: usize = 5;
+const IN_143: usize = 5;
+const OUT_143: usize = 4;
+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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_143] = [__v_1, __v_2, __v_3, __v_4];
+        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __ret: [G; OUT_143] = [__v_3, __v_4, __v_1, __v_2];
+        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_144: usize = 4;
+const IN_144: usize = 4;
+const OUT_144: usize = 1;
+fn aiur_fn_144(
+  inp: [G; IN_144],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_144], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(0);
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_0]; 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_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 = G::from_u64(0);
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1]; 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_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 __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_2]; 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 = G::from_u64(0);
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3]; 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_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 = 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 __v_43: G = { let __values: [G; 10] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __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 __v_45: G = { let __values: [G; 10] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_44]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_46];
+    record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_145: usize = 6;
+const IN_145: usize = 6;
+const OUT_145: usize = 3;
+fn aiur_fn_145(
+  inp: [G; IN_145],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_145], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    let __v_11: G = __loaded[5];
+    let __v_12: G = __loaded[6];
+    match __v_6.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_145] = [__v_0, __v_1, __v_5];
+        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_7.as_canonical_u64() {
+          _ => {
+            let __v_13: G = (__v_7 - __v_2);
+            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+            match __v_14.as_canonical_u64() {
+              1u64 => {
+                let __v_15: G = G::from_u64(1);
+                let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_3, __v_4, __v_15]; 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_16: G = __r_arr[0];
+                let __v_17: G = __r_arr[1];
+                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_16, __v_17, __v_10, __v_11]; 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_18: G = __r_arr[0];
+                let __v_19: G = __r_arr[1];
+                let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0, __v_1, __v_18, __v_19]; 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 __v_20: G = __r_arr[0];
+                let __v_21: G = __r_arr[1];
+                let __ret: [G; OUT_145] = [__v_20, __v_21, __v_12];
+                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __ret: [G; OUT_145] = [__v_0, __v_1, __v_5];
+                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_146: usize = 9;
+const IN_146: usize = 9;
+const OUT_146: usize = 2;
+fn aiur_fn_146(
+  inp: [G; IN_146],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_146], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_9: G = __loaded[0];
+    let __v_10: G = __loaded[1];
+    let __v_11: G = __loaded[2];
+    let __v_12: G = __loaded[3];
+    let __v_13: G = __loaded[4];
+    match __v_9.as_canonical_u64() {
+      1u64 => {
+        let __v_14: G = (__v_6 - __v_8);
+        let __v_15: G = G::from_bool((__v_14 == G::ZERO));
+        let __v_16: G = G::from_u64(1);
+        if (__v_15 != __v_16) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
+        }
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_7]; 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_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() });
+        }
+        let __ret: [G; OUT_146] = [__v_0, __v_1];
+        record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_14: G = __loaded[0];
+        let __v_15: G = __loaded[1];
+        let __v_16: G = __loaded[2];
+        let __v_17: G = __loaded[3];
+        match __v_14.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_18: G = __loaded[0];
+            let __v_19: G = __loaded[1];
+            let __v_20: G = __loaded[2];
+            match __v_18.as_canonical_u64() {
+              0u64 => {
+                match __v_10.as_canonical_u64() {
+                  _ => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_21: G = __loaded[0];
+                    let __v_22: G = __loaded[1];
+                    let __v_23: G = __loaded[2];
+                    match __v_21.as_canonical_u64() {
+                      0u64 => {
+                        let __v_24: G = G::from_u64(1);
+                        let __v_25: G = (__v_6 - __v_24);
+                        let __v_26: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                        let __v_27: G = __r_arr[0];
+                        let __v_28: G = __r_arr[1];
+                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_22, __v_0, __v_1, __v_27, __v_28]; 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_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_116] = { let __args: [G; IN_116] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_33: G = __r_arr[0];
+                        let __v_34: G = __r_arr[1];
+                        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_33, __v_34, __v_25, __v_15, __v_16, __v_7]; 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_35: G = __r_arr[0];
+                        let __v_36: G = __r_arr[1];
+                        let __v_37: G = __r_arr[2];
+                        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_11]; 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_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() });
+                        }
+                        let __v_40: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_29, __v_30, __v_31, __v_32]; 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_41: G = __r_arr[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 = { let __values: [G; 3] = [__v_40, __v_41, __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 = G::from_u64(1);
+                        let __v_48: G = G::from_u64(1);
+                        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 } };
+                        let __v_50: G = { let __values: [G; 3] = [__v_46, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_19, __v_45, __v_50, __v_23, __v_12, __v_25]; 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_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() });
+                        }
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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[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_53: G = __r_arr[0];
+                        let __v_54: G = __r_arr[1];
+                        let __ret: [G; OUT_146] = [__v_53, __v_54];
+                        record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_147: usize = 26;
+const IN_147: usize = 26;
+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 __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];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16, __v_20, __v_19, __v_21]; 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_26: G = __r_arr[0];
+        let __v_27: G = G::from_u64(0);
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_27]; 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_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        match __v_28.as_canonical_u64() {
+          _ => {
+            let __v_30: G = G::from_u64(0);
+            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_26, __v_0, __v_21, __v_20, __v_30, __v_19, __v_16, __v_17, __v_18, __v_28, __v_5, __v_3, __v_4]; 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 = G::from_u64(1);
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_32]; 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_33: G = __r_arr[0];
+            let __v_34: G = __r_arr[1];
+            match __v_33.as_canonical_u64() {
+              _ => {
+                let __v_35: G = G::from_u64(0);
+                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_31, __v_0, __v_21, __v_20, __v_35, __v_19, __v_16, __v_17, __v_18, __v_33, __v_6, __v_3, __v_4]; 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_36: G = __r_arr[0];
+                let __v_37: G = G::from_u64(2);
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_37]; 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_38: G = __r_arr[0];
+                let __v_39: G = __r_arr[1];
+                match __v_38.as_canonical_u64() {
+                  _ => {
+                    let __v_40: G = G::from_u64(0);
+                    let __v_41: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_36, __v_0, __v_21, __v_20, __v_40, __v_19, __v_41, __v_14, __v_16, __v_17, __v_18, __v_38, __v_7, __v_3, __v_4]; 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_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_42, __v_1, __v_13, __v_8, __v_9, __v_15, __v_16, __v_19, __v_0, __v_21, __v_20, __v_17, __v_18, __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_43: G = __r_arr[0];
+                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_43, __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_44: G = __r_arr[0];
+                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_43.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+                    let __v_45: G = __loaded[0];
+                    let __v_46: G = __loaded[1];
+                    let __v_47: G = __loaded[2];
+                    let __v_48: G = __loaded[3];
+                    let __v_49: G = __loaded[4];
+                    let __v_50: G = __loaded[5];
+                    let __v_51: G = __loaded[6];
+                    match __v_45.as_canonical_u64() {
+                      0u64 => {
+                        match __v_46.as_canonical_u64() {
+                          _ => {
+                            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_49, __v_50, __v_22, __v_23, __v_2, __v_0, __v_21, __v_51, __v_20]; 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_52: G = __r_arr[0];
+                            let __v_53: G = __r_arr[1];
+                            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__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_54: G = __r_arr[0];
+                            let __v_55: G = (__v_54 - __v_25);
+                            let __v_56: G = G::from_bool((__v_55 == G::ZERO));
+                            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() });
+                            }
+                            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__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_58: G = __r_arr[0];
+                            let __v_59: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_8, __v_9]; 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_60: G = __r_arr[0];
+                            let __v_61: G = (__v_59 + __v_60);
+                            let __v_62: G = (__v_58 - __v_61);
+                            let __v_63: G = G::from_bool((__v_62 == G::ZERO));
+                            let __v_64: G = G::from_u64(1);
+                            if (__v_63 != __v_64) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64() });
+                            }
+                            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_28]; 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_65: G = __r_arr[0];
+                            let __v_66: G = (__v_65 - __v_19);
+                            let __v_67: G = G::from_bool((__v_66 == G::ZERO));
+                            let __v_68: G = G::from_u64(1);
+                            if (__v_67 != __v_68) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64() });
+                            }
+                            let __v_69: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_16, __v_20, __v_19, __v_69]; 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_70: G = __r_arr[0];
+                            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10, __v_28, __v_70, __v_0, __v_29, __v_21]; 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_71: G = __r_arr[0];
+                            let __v_72: G = G::from_u64(1);
+                            if (__v_71 != __v_72) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64() });
+                            }
+                            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_33]; 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_73: G = __r_arr[0];
+                            let __v_74: G = (__v_73 - __v_19);
+                            let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+                            let __v_76: G = G::from_u64(1);
+                            if (__v_75 != __v_76) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64() });
+                            }
+                            let __v_77: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_16, __v_20, __v_19, __v_77]; 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_78: G = __r_arr[0];
+                            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_11, __v_33, __v_78, __v_0, __v_34, __v_21]; 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_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() });
+                            }
+                            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_38]; 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_81: G = __r_arr[0];
+                            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7]; 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 = (__v_81 - __v_82);
+                            let __v_84: G = G::from_bool((__v_83 == G::ZERO));
+                            let __v_85: G = G::from_u64(1);
+                            if (__v_84 != __v_85) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64() });
+                            }
+                            let __v_86: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_14, __v_16, __v_20, __v_19, __v_86]; 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_87: G = __r_arr[0];
+                            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12, __v_38, __v_87, __v_0, __v_39, __v_21]; 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_88: G = __r_arr[0];
+                            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() });
+                            }
+                            let __v_90: G = (__v_46 - __v_21);
+                            let __v_91: G = G::from_bool((__v_90 == G::ZERO));
+                            let __v_92: G = G::from_u64(1);
+                            if (__v_91 != __v_92) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_92.as_canonical_u64() });
+                            }
+                            let __v_93: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_24, __v_93]; 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_94: G = __r_arr[0];
+                            let __v_95: G = __r_arr[1];
+                            let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_94, __v_95, __v_52, __v_53]; 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_96: G = __r_arr[0];
+                            let __v_97: G = G::from_u64(1);
+                            if (__v_96 != __v_97) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_97.as_canonical_u64() });
+                            }
+                            let __v_98: G = G::from_u64(1);
+                            let __ret: [G; OUT_147] = [__v_98];
+                            record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_148: usize = 26;
+const IN_148: usize = 26;
+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 = 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 __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_26: G = __loaded[0];
+    let __v_27: G = __loaded[1];
+    let __v_28: G = __loaded[2];
+    let __v_29: G = __loaded[3];
+    match __v_26.as_canonical_u64() {
+      1u64 => {
+        let __v_30: G = G::from_u64(1);
+        let __ret: [G; OUT_148] = [__v_30];
+        record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_21]; 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_30: G = __r_arr[0];
+        let __v_31: G = __r_arr[1];
+        let __v_32: G = __r_arr[2];
+        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_30, __v_27, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; 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_33: G = __r_arr[0];
+        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_31, __v_32, __v_29, __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]; 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_34: G = __r_arr[0];
+        let __ret: [G; OUT_148] = [__v_34];
+        record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_149: usize = 31;
+const IN_149: usize = 31;
+const OUT_149: usize = 1;
+fn aiur_fn_149(
+  inp: [G; IN_149],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_149], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    match __v_6.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6]; 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_31: G = __r_arr[0];
+        let __v_32: G = G::from_u64(1);
+        let __v_33: G = G::from_u64(1);
+        let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_4, __v_5, __v_34]; 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_35: G = __r_arr[0];
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __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];
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __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];
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_37]; 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_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_38]; 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_39: G = __r_arr[0];
+        let __v_40: G = G::from_u64(1);
+        let __v_41: G = G::from_u64(1);
+        let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_39, __v_42]; 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_43: G = __r_arr[0];
+        let __v_44: G = __r_arr[1];
+        let __v_45: G = __r_arr[2];
+        let __v_46: G = __r_arr[3];
+        let __v_47: G = __r_arr[4];
+        let __v_48: G = __r_arr[5];
+        let __v_49: G = __r_arr[6];
+        let __v_50: G = __r_arr[7];
+        let __v_51: G = __r_arr[8];
+        let __v_52: G = __r_arr[9];
+        let __v_53: G = __r_arr[10];
+        let __v_54: G = __r_arr[11];
+        let __v_55: G = __r_arr[12];
+        let __v_56: G = __r_arr[13];
+        let __v_57: G = __r_arr[14];
+        let __v_58: G = __r_arr[15];
+        let __v_59: G = __r_arr[16];
+        let __v_60: G = __r_arr[17];
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_61: G = __r_arr[0];
+        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_62: G = __r_arr[0];
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_59, __v_6, __v_7, __v_30]; 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_63: G = __r_arr[0];
+        let __v_64: G = __r_arr[1];
+        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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_9, __v_67]; 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_68: G = __r_arr[0];
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_64, __v_68]; 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_69: G = __r_arr[0];
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_69, __v_6]; 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_70: G = __r_arr[0];
+        let __v_71: G = (__v_31 + __v_28);
+        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7]; 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_72: G = __r_arr[0];
+        let __v_73: G = (__v_72 - __v_31);
+        let __v_74: G = G::from_bool((__v_73 == G::ZERO));
+        let __v_75: G = G::from_u64(1);
+        if (__v_74 != __v_75) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_75.as_canonical_u64() });
+        }
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_8]; 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_76: G = __r_arr[0];
+        let __v_77: G = (__v_76 - __v_29);
+        let __v_78: G = G::from_bool((__v_77 == G::ZERO));
+        let __v_79: G = G::from_u64(1);
+        if (__v_78 != __v_79) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64() });
+        }
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_9]; 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_80: G = __r_arr[0];
+        let __v_81: G = G::from_u64(1);
+        if (__v_80 != __v_81) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_81.as_canonical_u64() });
+        }
+        let __v_82: G = G::from_u64(1);
+        let __v_83: G = G::from_u64(1);
+        let __v_84: G = { let __values: [G; 3] = [__v_82, __v_83, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_70, __v_84, __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_28, __v_71, __v_63, __v_6, __v_9, __v_31]; 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_85: G = __r_arr[0];
+        let __ret: [G; OUT_149] = [__v_85];
+        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_150: usize = 2;
+const IN_150: usize = 2;
+const OUT_150: usize = 1;
+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_bool((__v_0 == G::ZERO));
+    let __v_3: G = G::from_bool((__v_1 == G::ZERO));
+    let __v_4: G = (__v_2 * __v_3);
+    let __ret: [G; OUT_150] = [__v_4];
+    record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_151: usize = 1;
+const IN_151: usize = 1;
+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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_151] = [__v_5];
+        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_2, __v_3]; 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_9: G = __r_arr[0];
+            let __ret: [G; OUT_151] = [__v_9];
+            record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_4]; 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_9: G = __r_arr[0];
+            let __ret: [G; OUT_151] = [__v_9];
+            record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_152: usize = 9;
+const IN_152: usize = 9;
+const OUT_152: usize = 1;
+fn aiur_fn_152(
+  inp: [G; IN_152],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_152], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_152] = [__v_24];
+    record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_153: usize = 33;
+const IN_153: usize = 33;
+const OUT_153: usize = 1;
+fn aiur_fn_153(
+  inp: [G; IN_153],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_153], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__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[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_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_36: G = __r_arr[0];
+    let __ret: [G; OUT_153] = [__v_36];
+    record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_154: usize = 2;
+const IN_154: usize = 2;
+const OUT_154: usize = 1;
+fn aiur_fn_154(
+  inp: [G; IN_154],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_154], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __v_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];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_154] = [__v_1];
+        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_35, __v_1]; 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_36: G = __r_arr[0];
+        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__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_36]; 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_37: G = __r_arr[0];
+        let __ret: [G; OUT_154] = [__v_37];
+        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_155: usize = 2;
+const IN_155: usize = 2;
+const OUT_155: usize = 1;
+fn aiur_fn_155(
+  inp: [G; IN_155],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_155], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_155] = [__v_1];
+        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_4, __v_1]; 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_13: G = __r_arr[0];
+        let __ret: [G; OUT_155] = [__v_13];
+        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_156: usize = 2;
+const IN_156: usize = 2;
+const OUT_156: usize = 3;
+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; 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 __ret: [G; OUT_156] = [__v_3, __v_0, __v_4];
+        record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0]; 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_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 = 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_95] = { let __args: [G; IN_95] = [__v_5, __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_39]; 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_40: G = __r_arr[0];
+        let __v_41: G = G::from_u64(1);
+        let __v_42: G = G::from_u64(1);
+        let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __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 __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_40, __v_43]; 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_44: 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_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_45: G = __loaded[0];
+        let __v_46: G = __loaded[1];
+        let __v_47: G = __loaded[2];
+        match __v_45.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_156] = [__v_46, __v_40, __v_47];
+            record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_157: usize = 2;
+const IN_157: usize = 2;
+const OUT_157: usize = 10;
+fn aiur_fn_157(
+  inp: [G; IN_157],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_157], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_3, __v_4]; 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __v_7: G = __r_arr[2];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __v_10: G = __r_arr[2];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_9, __v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_12, __v_13]; 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_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __v_16: G = __r_arr[2];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_15, __v_16]; 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_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __v_19: G = __r_arr[2];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_18, __v_19]; 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_20: G = __r_arr[0];
+    let __v_21: G = __r_arr[1];
+    let __v_22: G = __r_arr[2];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_21, __v_22]; 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_23: G = __r_arr[0];
+    let __v_24: G = __r_arr[1];
+    let __v_25: G = __r_arr[2];
+    let __ret: [G; OUT_157] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_24, __v_25];
+    record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_158: usize = 2;
+const IN_158: usize = 2;
+const OUT_158: usize = 10;
+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 __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __r_arr: [G; OUT_11] = { let __args: [G; IN_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[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_12: G = __r_arr[0];
+    match __v_12.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_158] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_10, __v_11]; 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = __r_arr[2];
+        let __v_16: G = __r_arr[3];
+        let __v_17: G = __r_arr[4];
+        let __v_18: G = __r_arr[5];
+        let __v_19: G = __r_arr[6];
+        let __v_20: G = __r_arr[7];
+        let __v_21: G = __r_arr[8];
+        let __v_22: G = __r_arr[9];
+        let __ret: [G; OUT_158] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_159: usize = 2;
+const IN_159: usize = 2;
+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 __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_10, __v_11]; 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_12: G = __r_arr[0];
+    let __v_13: G = __r_arr[1];
+    let __v_14: G = __r_arr[2];
+    let __v_15: G = __r_arr[3];
+    let __v_16: G = __r_arr[4];
+    let __v_17: G = __r_arr[5];
+    let __v_18: G = __r_arr[6];
+    let __v_19: G = __r_arr[7];
+    let __v_20: G = __r_arr[8];
+    let __v_21: G = __r_arr[9];
+    let __ret: [G; OUT_159] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_160: usize = 8;
+const IN_160: usize = 8;
+const OUT_160: usize = 1;
+fn aiur_fn_160(
+  inp: [G; IN_160],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_160], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_0); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_0, record) };
+    let __v_8: G = __b1_out[0];
+    let __v_9: G = __b1_out[1];
+    let __v_10: G = __b1_out[2];
+    let __v_11: G = __b1_out[3];
+    let __v_12: G = __b1_out[4];
+    let __v_13: G = __b1_out[5];
+    let __v_14: G = __b1_out[6];
+    let __v_15: G = __b1_out[7];
+    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_16: G = __b1_out[0];
+    let __v_17: G = __b1_out[1];
+    let __v_18: G = __b1_out[2];
+    let __v_19: G = __b1_out[3];
+    let __v_20: G = __b1_out[4];
+    let __v_21: G = __b1_out[5];
+    let __v_22: G = __b1_out[6];
+    let __v_23: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record) };
+    let __v_24: G = __b1_out[0];
+    let __v_25: G = __b1_out[1];
+    let __v_26: G = __b1_out[2];
+    let __v_27: G = __b1_out[3];
+    let __v_28: G = __b1_out[4];
+    let __v_29: G = __b1_out[5];
+    let __v_30: G = __b1_out[6];
+    let __v_31: G = __b1_out[7];
+    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_32: G = __b1_out[0];
+    let __v_33: G = __b1_out[1];
+    let __v_34: G = __b1_out[2];
+    let __v_35: G = __b1_out[3];
+    let __v_36: G = __b1_out[4];
+    let __v_37: G = __b1_out[5];
+    let __v_38: G = __b1_out[6];
+    let __v_39: 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_40: G = __b1_out[0];
+    let __v_41: G = __b1_out[1];
+    let __v_42: G = __b1_out[2];
+    let __v_43: G = __b1_out[3];
+    let __v_44: G = __b1_out[4];
+    let __v_45: G = __b1_out[5];
+    let __v_46: G = __b1_out[6];
+    let __v_47: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) };
+    let __v_48: G = __b1_out[0];
+    let __v_49: G = __b1_out[1];
+    let __v_50: G = __b1_out[2];
+    let __v_51: G = __b1_out[3];
+    let __v_52: G = __b1_out[4];
+    let __v_53: G = __b1_out[5];
+    let __v_54: G = __b1_out[6];
+    let __v_55: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) };
+    let __v_56: G = __b1_out[0];
+    let __v_57: G = __b1_out[1];
+    let __v_58: G = __b1_out[2];
+    let __v_59: G = __b1_out[3];
+    let __v_60: G = __b1_out[4];
+    let __v_61: G = __b1_out[5];
+    let __v_62: G = __b1_out[6];
+    let __v_63: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_7); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_7, record) };
+    let __v_64: G = __b1_out[0];
+    let __v_65: G = __b1_out[1];
+    let __v_66: G = __b1_out[2];
+    let __v_67: G = __b1_out[3];
+    let __v_68: G = __b1_out[4];
+    let __v_69: G = __b1_out[5];
+    let __v_70: G = __b1_out[6];
+    let __v_71: G = __b1_out[7];
+    let __v_72: G = G::from_u64(1);
+    let __v_73: G = G::from_u64(1);
+    let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_74]; 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_75: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_75]; 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_76: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_76]; 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_77: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_77]; 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_78: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_78]; 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_79: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_79]; 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_80: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_80]; 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_81: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_81]; 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_82: G = __r_arr[0];
+    let __ret: [G; OUT_160] = [__v_82];
+    record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_161: usize = 2;
+const IN_161: usize = 2;
+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];
+    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_161] = [__v_4];
+        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4, __v_7]; 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_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_161] = [__v_9];
+            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_162: usize = 3;
+const IN_162: usize = 3;
+const OUT_162: usize = 3;
+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 __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1]; 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 __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 __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__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[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_161] = { let __args: [G; IN_161] = [__v_13, __v_2]; 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_14: G = __r_arr[0];
+    let __ret: [G; OUT_162] = [__v_14, __v_11, __v_12];
+    record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_163: usize = 9;
+const IN_163: usize = 9;
+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 = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = G::from_u64(1);
+    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_12]; 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_13: G = __r_arr[0];
+    let __ret: [G; OUT_163] = [__v_13];
+    record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_164: usize = 2;
+const IN_164: usize = 2;
+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 = 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_154] = { let __args: [G; IN_154] = [__v_1, __v_4]; 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
+    let __ret: [G; OUT_164] = [__v_6];
+    record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_165: usize = 2;
+const IN_165: usize = 2;
+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 __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_165] = [__v_1];
+        record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_11, __v_1]; 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_152] = { let __args: [G; IN_152] = [__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[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_13: G = __r_arr[0];
+        let __ret: [G; OUT_165] = [__v_13];
+        record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_166: usize = 2;
+const IN_166: usize = 2;
+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 __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_166] = [__v_1];
+        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_3]; 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_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 __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_4, __v_1]; 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_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_3, __v_13]; 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_14: G = __r_arr[0];
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; 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_15: G = __r_arr[0];
+        let __ret: [G; OUT_166] = [__v_15];
+        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_167: usize = 2;
+const IN_167: usize = 2;
+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 __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_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 __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; 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_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__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[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_11: G = __r_arr[0];
+    let __ret: [G; OUT_167] = [__v_11];
+    record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_168: usize = 1;
+const IN_168: usize = 1;
+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_168], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __v_2: G = G::from_u64(109);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = G::from_u64(117);
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(108);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(116);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(105);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(45);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(115);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(116);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = G::from_u64(97);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(114);
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(107);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(47);
+    let __v_25: G = G::from_u64(0);
+    let __v_26: G = G::from_u64(118);
+    let __v_27: G = G::from_u64(0);
+    let __v_28: G = G::from_u64(48);
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_168] = [__v_42];
+    record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_169: usize = 2;
+const IN_169: usize = 2;
+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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __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(&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_169] = [__v_4];
+        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __ret: [G; OUT_169] = [__v_1];
+        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_170: usize = 9;
+const IN_170: usize = 9;
+const OUT_170: usize = 9;
+fn aiur_fn_170(
+  inp: [G; IN_170],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_170], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = 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_167] = { let __args: [G; IN_167] = [__v_7, __v_11]; 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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_6, __v_12]; 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_13: G = __r_arr[0];
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_3, __v_13]; 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_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_2, __v_14]; 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_15: G = __r_arr[0];
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_1, __v_15]; 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_16: G = __r_arr[0];
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_16]; 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_17: G = __r_arr[0];
+    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_17]; 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_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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_18, __v_21]; 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_22: G = __r_arr[0];
+    let __v_23: G = __r_arr[1];
+    let __v_24: G = __r_arr[2];
+    let __v_25: G = __r_arr[3];
+    let __v_26: G = __r_arr[4];
+    let __v_27: G = __r_arr[5];
+    let __v_28: G = __r_arr[6];
+    let __v_29: G = __r_arr[7];
+    let __v_30: G = __r_arr[8];
+    let __v_31: G = __r_arr[9];
+    let __v_32: G = __r_arr[10];
+    let __v_33: G = __r_arr[11];
+    let __v_34: G = __r_arr[12];
+    let __v_35: G = __r_arr[13];
+    let __v_36: G = __r_arr[14];
+    let __v_37: G = __r_arr[15];
+    let __v_38: G = __r_arr[16];
+    let __v_39: G = __r_arr[17];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_38, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_40: G = __r_arr[0];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_40, __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[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_41: G = __r_arr[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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_41, __v_44]; 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_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 = __r_arr[4];
+    let __v_50: G = __r_arr[5];
+    let __v_51: G = __r_arr[6];
+    let __v_52: G = __r_arr[7];
+    let __v_53: G = __r_arr[8];
+    let __v_54: G = __r_arr[9];
+    let __v_55: G = __r_arr[10];
+    let __v_56: G = __r_arr[11];
+    let __v_57: G = __r_arr[12];
+    let __v_58: G = __r_arr[13];
+    let __v_59: G = __r_arr[14];
+    let __v_60: G = __r_arr[15];
+    let __v_61: G = __r_arr[16];
+    let __v_62: G = __r_arr[17];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_61, __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[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_63: G = __r_arr[0];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_63, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; 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_64: G = __r_arr[0];
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_64, __v_4]; 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_65: G = __r_arr[0];
+    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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_8, __v_68]; 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_69: G = __r_arr[0];
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_65, __v_69]; 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_70: G = __r_arr[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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_70, __v_73]; 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_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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_90, __v_5]; 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_92: G = __r_arr[0];
+    let __v_93: G = G::from_u64(1);
+    let __v_94: G = G::from_u64(1);
+    let __v_95: G = { let __values: [G; 3] = [__v_93, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_92, __v_95]; 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_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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_114: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_115: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_116: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; 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_117: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_118: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; 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_119: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_120: G = __r_arr[0];
+    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_121: G = __r_arr[0];
+    let __ret: [G; OUT_170] = [__v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_112];
+    record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_171: usize = 3;
+const IN_171: usize = 3;
+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];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_171] = [__v_0, __v_1];
+        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_0, __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 __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_2 - __v_5);
+        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_3, __v_4, __v_6]; 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_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __ret: [G; OUT_171] = [__v_7, __v_8];
+        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_1: G = G::from_u64(18446744069414584320);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_1: G = G::from_u64(281474976710656);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_1: G = G::from_u64(18446744069397807105);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_1: G = G::from_u64(17293822564807737345);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_1: G = G::from_u64(70368744161280);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_1: G = G::from_u64(549755813888);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_1: G = G::from_u64(17870292113338400769);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_1: G = G::from_u64(13797081185216407910);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_1: G = G::from_u64(1803076106186727246);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_1: G = G::from_u64(11353340290879379826);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      11u64 => {
+        let __v_1: G = G::from_u64(455906449640507599);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      12u64 => {
+        let __v_1: G = G::from_u64(17492915097719143606);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      13u64 => {
+        let __v_1: G = G::from_u64(1532612707718625687);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      14u64 => {
+        let __v_1: G = G::from_u64(16207902636198568418);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      15u64 => {
+        let __v_1: G = G::from_u64(17776499369601055404);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      16u64 => {
+        let __v_1: G = G::from_u64(6115771955107415310);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      17u64 => {
+        let __v_1: G = G::from_u64(12380578893860276750);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      18u64 => {
+        let __v_1: G = G::from_u64(9306717745644682924);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      19u64 => {
+        let __v_1: G = G::from_u64(18146160046829613826);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      20u64 => {
+        let __v_1: G = G::from_u64(3511170319078647661);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      21u64 => {
+        let __v_1: G = G::from_u64(17654865857378133588);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      22u64 => {
+        let __v_1: G = G::from_u64(5416168637041100469);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      23u64 => {
+        let __v_1: G = G::from_u64(16905767614792059275);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      24u64 => {
+        let __v_1: G = G::from_u64(9713644485405565297);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      25u64 => {
+        let __v_1: G = G::from_u64(5456943929260765144);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      26u64 => {
+        let __v_1: G = G::from_u64(17096174751763063430);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      27u64 => {
+        let __v_1: G = G::from_u64(1213594585890690845);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      28u64 => {
+        let __v_1: G = G::from_u64(6414415596519834757);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      29u64 => {
+        let __v_1: G = G::from_u64(16116352524544190054);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      30u64 => {
+        let __v_1: G = G::from_u64(9123114210336311365);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      31u64 => {
+        let __v_1: G = G::from_u64(4614640910117430873);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(1753635133440165772);
+        let __ret: [G; OUT_172] = [__v_1];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_173: usize = 3;
+const IN_173: usize = 3;
+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_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 __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(0);
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_3, __v_4, __v_5, __v_6]; 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_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __ret: [G; OUT_173] = [__v_7, __v_8];
+    record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_174: usize = 3;
+const IN_174: usize = 3;
+const OUT_174: usize = 8;
+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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_2]; 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_5]; 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_6: G = __r_arr[0];
+    let __v_7: G = G::from_u64(1);
+    let __v_8: G = G::from_u64(0);
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0, __v_1, __v_7, __v_8]; 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_3, __v_4, __v_9, __v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = G::from_u64(0);
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0, __v_1, __v_6, __v_13]; 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_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_3, __v_4, __v_14, __v_15]; 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_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    let __v_18: G = G::from_u64(0);
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0, __v_1, __v_6, __v_18]; 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_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_3, __v_4]; 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_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __ret: [G; OUT_174] = [__v_11, __v_12, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22];
+    record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_175: usize = 23;
+const IN_175: usize = 23;
+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_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 __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];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4]; 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_23: G = __r_arr[0];
+        let __v_24: G = G::from_bool((__v_23 == G::ZERO));
+        let __v_25: G = G::from_u64(0);
+        if (__v_24 != __v_25) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64() });
+        }
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_21]; 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_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() });
+        }
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_22]; 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_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() });
+        }
+        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_4]; 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_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() });
+        }
+        let __v_30: G = G::from_u64(1);
+        let __ret: [G; OUT_175] = [__v_30];
+        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_176: usize = 6;
+const IN_176: usize = 6;
+const OUT_176: usize = 2;
+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 __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_2, __v_3]; 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_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_4, __v_5]; 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 __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __ret: [G; OUT_176] = [__v_8, __v_9];
+    record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_177: usize = 4;
+const IN_177: usize = 4;
+const OUT_177: usize = 2;
+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 __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(0);
+    let __v_5: G = G::from_u64(1);
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_2, __v_3, __v_4, __v_5]; 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_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0, __v_1, __v_6, __v_7]; 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 __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __ret: [G; OUT_177] = [__v_8, __v_9];
+    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_178: usize = 1;
+const IN_178: usize = 1;
+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 __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 __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_178] = [__v_7];
+        record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = G::from_u64(0);
+            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2, __v_3, __v_6, __v_7]; 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_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_8]; 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_12: G = __r_arr[0];
+            let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_178] = [__v_13];
+            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_179: usize = 6;
+const IN_179: usize = 6;
+const OUT_179: usize = 2;
+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 __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4, __v_3]; 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __ret: [G; OUT_179] = [__v_6, __v_7];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_3]; 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __ret: [G; OUT_179] = [__v_6, __v_7];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(0);
+            let __ret: [G; OUT_179] = [__v_6, __v_7];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(0);
+            let __ret: [G; OUT_179] = [__v_6, __v_7];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(0);
+            let __ret: [G; OUT_179] = [__v_6, __v_7];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          5u64 => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(0);
+            let __ret: [G; OUT_179] = [__v_6, __v_7];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+          },
+        }
+      },
+      1u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_179] = [__v_6, __v_7];
+        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_179] = [__v_6, __v_7];
+        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_179] = [__v_6, __v_7];
+        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_179] = [__v_1, __v_6];
+        record.function_queries[179].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];
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_6, __v_7, __v_8, __v_9, __v_4, __v_5]; 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_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_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_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_12, __v_13, __v_14, __v_15, __v_4, __v_5]; 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_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_16, __v_17]; 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 __v_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __ret: [G; OUT_179] = [__v_18, __v_19];
+        record.function_queries[179].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_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_179] = { let __args: [G; IN_179] = [__v_6, __v_7, __v_8, __v_9, __v_4, __v_5]; 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_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_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_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_12, __v_13, __v_14, __v_15, __v_4, __v_5]; 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_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_10, __v_11, __v_16, __v_17]; 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_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __ret: [G; OUT_179] = [__v_18, __v_19];
+        record.function_queries[179].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_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_179] = { let __args: [G; IN_179] = [__v_6, __v_7, __v_8, __v_9, __v_4, __v_5]; 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_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_10, __v_11]; 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_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __ret: [G; OUT_179] = [__v_12, __v_13];
+        record.function_queries[179].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_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_179] = { let __args: [G; IN_179] = [__v_6, __v_7, __v_8, __v_9, __v_4, __v_5]; 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_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_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_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_12, __v_13, __v_14, __v_15, __v_4, __v_5]; 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_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_10, __v_11, __v_16, __v_17]; 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_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __ret: [G; OUT_179] = [__v_18, __v_19];
+        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_180: usize = 5;
+const IN_180: usize = 5;
+const OUT_180: usize = 2;
+fn aiur_fn_180(
+  inp: [G; IN_180],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_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(0);
+        let __ret: [G; OUT_180] = [__v_11, __v_12];
+        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_6, __v_7, __v_8, __v_9, __v_3, __v_4]; 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_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_10, __v_3, __v_4]; 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_13, __v_14]; 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_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_11, __v_12, __v_15, __v_16]; 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 __v_17: G = __r_arr[0];
+        let __v_18: G = __r_arr[1];
+        let __ret: [G; OUT_180] = [__v_17, __v_18];
+        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_181: usize = 6;
+const IN_181: usize = 6;
+const OUT_181: usize = 2;
+fn aiur_fn_181(
+  inp: [G; IN_181],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_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 __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_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];
+    match __v_6.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_181] = [__v_0, __v_1];
+        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_13, __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 __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_7, __v_8, __v_9, __v_10, __v_5, __v_14]; 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_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2, __v_3, __v_15, __v_16]; 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_17: G = __r_arr[0];
+        let __v_18: G = __r_arr[1];
+        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_17, __v_18, __v_2, __v_3, __v_11, __v_5]; 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __ret: [G; OUT_181] = [__v_19, __v_20];
+        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_182: usize = 7;
+const IN_182: usize = 7;
+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 = 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_6.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_182] = [__v_0, __v_1];
+        record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4, __v_5]; 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_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7, __v_8, __v_9, __v_10]; 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_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_7, __v_8, __v_11, __v_12]; 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2, __v_3, __v_13, __v_14]; 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_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = (__v_5 + __v_17);
+        let __v_19: G = G::from_u64(1);
+        let __v_20: G = (__v_6 - __v_19);
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_15, __v_16, __v_2, __v_3, __v_4, __v_18, __v_20]; 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_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __ret: [G; OUT_182] = [__v_21, __v_22];
+        record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_183: usize = 15;
+const IN_183: usize = 15;
+const OUT_183: usize = 4;
+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 __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; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; 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: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].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];
+    match __v_15.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_183] = [__v_0, __v_1, __v_13, __v_14];
+        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_16.as_canonical_u64() {
+          _ => {
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = (__v_5 + __v_22);
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_23]; 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_24: G = __r_arr[0];
+            let __v_25: G = __r_arr[1];
+            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_16, __v_17, __v_18, __v_19, __v_6, __v_7]; 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_26: G = __r_arr[0];
+            let __v_27: G = __r_arr[1];
+            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_11, __v_12, __v_20, __v_6, __v_7]; 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_28: G = __r_arr[0];
+            let __v_29: G = __r_arr[1];
+            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_28, __v_29]; 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 __v_30: G = __r_arr[0];
+            let __v_31: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_30, __v_31, __v_24, __v_25]; 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_32: G = __r_arr[0];
+            let __v_33: G = __r_arr[1];
+            let __v_34: G = G::from_u64(1);
+            let __v_35: G = G::from_u64(0);
+            let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_32, __v_33, __v_34, __v_35]; 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_36: G = __r_arr[0];
+            let __v_37: G = __r_arr[1];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2, __v_3, __v_36, __v_37]; 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_38: G = __r_arr[0];
+            let __v_39: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_26, __v_27, __v_24, __v_25]; 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_40: G = __r_arr[0];
+            let __v_41: G = __r_arr[1];
+            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_13, __v_14, __v_40, __v_41]; 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 __v_42: G = __r_arr[0];
+            let __v_43: G = __r_arr[1];
+            let __v_44: G = G::from_u64(1);
+            let __v_45: G = (__v_5 + __v_44);
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_38, __v_39, __v_2, __v_3, __v_21, __v_45, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_42, __v_43]; 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_46: G = __r_arr[0];
+            let __v_47: G = __r_arr[1];
+            let __v_48: G = __r_arr[2];
+            let __v_49: G = __r_arr[3];
+            let __ret: [G; OUT_183] = [__v_46, __v_47, __v_48, __v_49];
+            record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_184: usize = 27;
+const IN_184: usize = 27;
+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 = 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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          _ => {
+            let __v_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_27, __v_28, __v_25, __v_26, __v_1, __v_6]; 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_29: G = __r_arr[0];
+            let __v_30: G = __r_arr[1];
+            let __v_31: G = (__v_3 - __v_2);
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_29, __v_30, __v_25, __v_26, __v_6, __v_2, __v_31]; 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_32: G = __r_arr[0];
+            let __v_33: G = __r_arr[1];
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_32, __v_33, __v_5, __v_6, __v_10, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __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[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_34: G = __r_arr[0];
+            let __v_35: G = __r_arr[1];
+            let __ret: [G; OUT_184] = [__v_34, __v_35];
+            record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      1u64 => {
+        match __v_1.as_canonical_u64() {
+          _ => {
+            let __v_27: G = G::from_u64(1);
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_6, __v_27]; 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_28: G = __r_arr[0];
+            let __v_29: G = __r_arr[1];
+            let __v_30: G = G::from_u64(2);
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_6, __v_30]; 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_31: G = __r_arr[0];
+            let __v_32: G = __r_arr[1];
+            let __v_33: G = G::from_u64(1);
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_7, __v_33]; 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_34: G = __r_arr[0];
+            let __v_35: G = __r_arr[1];
+            let __v_36: G = G::from_u64(2);
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_7, __v_36]; 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_37: G = __r_arr[0];
+            let __v_38: G = __r_arr[1];
+            let __v_39: G = G::from_u64(0);
+            let __v_40: G = G::from_u64(0);
+            let __v_41: G = G::from_u64(1);
+            let __v_42: G = G::from_u64(0);
+            let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_28, __v_29, __v_41, __v_42]; 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_43: G = __r_arr[0];
+            let __v_44: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_28, __v_29, __v_43, __v_44]; 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_45: G = __r_arr[0];
+            let __v_46: G = __r_arr[1];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_39, __v_40, __v_25, __v_26, __v_45, __v_46]; 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_47: G = __r_arr[0];
+            let __v_48: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_34, __v_35, __v_15, __v_16]; 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_49: G = __r_arr[0];
+            let __v_50: G = __r_arr[1];
+            let __v_51: G = G::from_u64(1);
+            let __v_52: G = G::from_u64(0);
+            let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_28, __v_29, __v_51, __v_52]; 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_53: G = __r_arr[0];
+            let __v_54: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_49, __v_50, __v_53, __v_54]; 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_55: G = __r_arr[0];
+            let __v_56: G = __r_arr[1];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_47, __v_48, __v_25, __v_26, __v_55, __v_56]; 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_57: G = __r_arr[0];
+            let __v_58: G = __r_arr[1];
+            let __v_59: G = G::from_u64(1);
+            let __v_60: G = G::from_u64(0);
+            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_31, __v_32, __v_59, __v_60]; 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 __v_61: G = __r_arr[0];
+            let __v_62: G = __r_arr[1];
+            let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_61, __v_62, __v_37, __v_38]; 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_63: G = __r_arr[0];
+            let __v_64: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_49, __v_50, __v_63, __v_64]; 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_65: G = __r_arr[0];
+            let __v_66: G = __r_arr[1];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_57, __v_58, __v_25, __v_26, __v_65, __v_66]; 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_67: G = __r_arr[0];
+            let __v_68: G = __r_arr[1];
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_67, __v_68, __v_5, __v_6, __v_10, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __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[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_69: G = __r_arr[0];
+            let __v_70: G = __r_arr[1];
+            let __ret: [G; OUT_184] = [__v_69, __v_70];
+            record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      2u64 => {
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = G::from_u64(0);
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_27, __v_28, __v_5, __v_6, __v_10, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __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[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_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __ret: [G; OUT_184] = [__v_29, __v_30];
+        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = G::from_u64(0);
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_27, __v_28, __v_5, __v_6, __v_10, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __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[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_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __ret: [G; OUT_184] = [__v_29, __v_30];
+        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_185: usize = 23;
+const IN_185: usize = 23;
+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 __v_0: G = inp[0];
+    let __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 = G::from_u64(0);
+    let __v_24: G = G::from_u64(0);
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_24]; 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_25: G = __r_arr[0];
+    let __v_26: G = __r_arr[1];
+    let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_21, __v_22, __v_2, __v_23, __v_3, __v_4, __v_5, __v_13, __v_14, __v_15, __v_16, __v_25, __v_26]; 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_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 = G::from_u64(0);
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_31]; 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_32: G = __r_arr[0];
+    let __v_33: G = __r_arr[1];
+    let __v_34: G = G::from_u64(0);
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_6, __v_34]; 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_35: G = __r_arr[0];
+    let __v_36: G = __r_arr[1];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_32, __v_33, __v_17, __v_18]; 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_37: G = __r_arr[0];
+    let __v_38: G = __r_arr[1];
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_7, __v_8, __v_37, __v_38]; 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_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_27, __v_28, __v_21, __v_22, __v_39, __v_40]; 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_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_29, __v_30, __v_35, __v_36]; 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_43: G = __r_arr[0];
+    let __v_44: G = __r_arr[1];
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_11, __v_12, __v_43, __v_44]; 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_45: G = __r_arr[0];
+    let __v_46: G = __r_arr[1];
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_41, __v_42, __v_21, __v_22, __v_45, __v_46]; 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_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_29, __v_30, __v_19, __v_20]; 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_49: G = __r_arr[0];
+    let __v_50: G = __r_arr[1];
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_9, __v_10, __v_49, __v_50]; 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_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_47, __v_48, __v_21, __v_22, __v_51, __v_52]; 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_53: G = __r_arr[0];
+    let __v_54: G = __r_arr[1];
+    let __ret: [G; OUT_185] = [__v_53, __v_54];
+    record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_186: usize = 2;
+const IN_186: usize = 2;
+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 = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_186] = [__v_2];
+        record.function_queries[186].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_186] = { let __args: [G; IN_186] = [__v_0, __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_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_0, __v_4]; 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_5: G = __r_arr[0];
+        let __ret: [G; OUT_186] = [__v_5];
+        record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_187: usize = 4;
+const IN_187: usize = 4;
+const OUT_187: usize = 2;
+fn aiur_fn_187(
+  inp: [G; IN_187],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_187], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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 __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_3, __v_4]; 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_5, __v_6, __v_2]; 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_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = G::from_u64(0);
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7, __v_8, __v_9, __v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __ret: [G; OUT_187] = [__v_11, __v_12];
+    record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_188: usize = 10;
+const IN_188: usize = 10;
+const OUT_188: usize = 2;
+fn aiur_fn_188(
+  inp: [G; IN_188],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_188], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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_8.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_188] = [__v_0, __v_1];
+        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_10: G = G::from_u64(7);
+        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_7]; 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_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11]; 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 __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_12]; 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_13: G = __r_arr[0];
+        let __v_14: G = (__v_7 - __v_9);
+        let __v_15: G = G::from_bool((__v_14 == G::ZERO));
+        match __v_15.as_canonical_u64() {
+          1u64 => {
+            let __v_16: G = G::from_u64(1);
+            let __v_17: G = (__v_7 + __v_16);
+            let __v_18: G = G::from_u64(1);
+            let __v_19: G = (__v_8 - __v_18);
+            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_17, __v_19, __v_9]; 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_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __ret: [G; OUT_188] = [__v_20, __v_21];
+            record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_2, __v_3, __v_4, __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_16: G = __r_arr[0];
+            let __v_17: G = __r_arr[1];
+            let __v_18: G = G::from_u64(0);
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6, __v_18, __v_4, __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_19: G = __r_arr[0];
+            let __v_20: G = __r_arr[1];
+            let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_19, __v_20]; 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_16, __v_17, __v_21, __v_22]; 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_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_23, __v_24]; 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_25: G = __r_arr[0];
+            let __v_26: G = __r_arr[1];
+            let __v_27: G = G::from_u64(1);
+            let __v_28: G = (__v_7 + __v_27);
+            let __v_29: G = G::from_u64(1);
+            let __v_30: G = (__v_8 - __v_29);
+            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_25, __v_26, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28, __v_30, __v_9]; 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_31: G = __r_arr[0];
+            let __v_32: G = __r_arr[1];
+            let __ret: [G; OUT_188] = [__v_31, __v_32];
+            record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_189: usize = 11;
+const IN_189: usize = 11;
+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 __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_9.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_189] = [__v_0, __v_1];
+        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_11: G = G::from_u64(7);
+        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_6, __v_10]; 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12]; 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_13: G = __r_arr[0];
+        let __v_14: G = G::from_u64(1);
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = G::from_u64(0);
+        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_14, __v_15, __v_2, __v_3, __v_4, __v_6, __v_13, __v_16, __v_5, __v_10]; 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_17: G = __r_arr[0];
+        let __v_18: G = __r_arr[1];
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_8]; 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_19: G = __r_arr[0];
+        let __v_20: G = G::from_u64(0);
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_19, __v_20]; 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_21: G = __r_arr[0];
+        let __v_22: G = G::from_u64(0);
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_21, __v_22]; 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_23: G = __r_arr[0];
+        let __v_24: G = __r_arr[1];
+        let __v_25: G = G::from_u64(1);
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_21, __v_25]; 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_26: G = __r_arr[0];
+        let __v_27: G = __r_arr[1];
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_23, __v_24, __v_26, __v_27]; 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_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_17, __v_18, __v_28, __v_29]; 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_30: G = __r_arr[0];
+        let __v_31: G = __r_arr[1];
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0, __v_1, __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 __v_32: G = __r_arr[0];
+        let __v_33: G = __r_arr[1];
+        let __v_34: G = G::from_u64(1);
+        let __v_35: G = (__v_8 + __v_34);
+        let __v_36: G = G::from_u64(1);
+        let __v_37: G = (__v_9 - __v_36);
+        let __v_38: G = G::from_u64(1);
+        let __v_39: G = (__v_10 + __v_38);
+        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_32, __v_33, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35, __v_37, __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 __ret: [G; OUT_189] = [__v_40, __v_41];
+        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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      11u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      12u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      13u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      14u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      15u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      16u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      17u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(32);
+        let __ret: [G; OUT_190] = [__v_1];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_191: usize = 1;
+const IN_191: usize = 1;
+const OUT_191: usize = 1;
+fn aiur_fn_191(
+  inp: [G; IN_191],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_191], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_1: G = G::from_u64(3);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_1: G = G::from_u64(3);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_1: G = G::from_u64(3);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_1: G = G::from_u64(3);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      11u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      12u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      13u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      14u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      15u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      16u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      17u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(5);
+        let __ret: [G; OUT_191] = [__v_1];
+        record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_192: usize = 4;
+const IN_192: usize = 4;
+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 __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __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_192] = [__v_6];
+        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        match __v_0.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; 4] = [__v_4, __v_5, __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_192] = [__v_6];
+            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_1, __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 = G::from_u64(0);
+            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_5]; 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_6: G = __r_arr[0];
+            let __ret: [G; OUT_192] = [__v_6];
+            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_193: usize = 21;
+const IN_193: usize = 21;
+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 __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 __loaded: [G; 14] = { let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 14 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 14] = __args[..14].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 __v_33: G = __loaded[12];
+    let __v_34: G = __loaded[13];
+    match __v_21.as_canonical_u64() {
+      1u64 => {
+        let __v_35: G = G::from_u64(1);
+        let __ret: [G; OUT_193] = [__v_35];
+        record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_22.as_canonical_u64() {
+          _ => {
+            match __v_22.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_9]; 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_35: G = __r_arr[0];
+                let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_29]; 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_36: G = __r_arr[0];
+                let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_29]; 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_37: G = __r_arr[0];
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !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_38: G = __r_arr[0];
+                let __v_39: G = __r_arr[1];
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_9]; 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_40: G = __r_arr[0];
+                let __v_41: G = G::from_u64(0);
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_40, __v_41]; 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_42: G = __r_arr[0];
+                let __v_43: G = G::from_u64(1);
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_40, __v_43]; 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_44: G = __r_arr[0];
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_9]; 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_45: G = __r_arr[0];
+                let __v_46: G = G::from_u64(0);
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_45, __v_46]; 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_47: G = __r_arr[0];
+                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_47]; 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_48: G = __r_arr[0];
+                let __v_49: G = G::from_u64(1);
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_45, __v_49]; 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_50: G = __r_arr[0];
+                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_50]; 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_51: G = __r_arr[0];
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !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_52: G = __r_arr[0];
+                let __v_53: G = __r_arr[1];
+                let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_7, __v_52, __v_53]; 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_54: G = __r_arr[0];
+                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_19, __v_20, __v_35]; 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_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 __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_42, __v_44, __v_48, __v_51, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_13, __v_14, __v_15, __v_16, __v_10, __v_11, __v_38, __v_39, __v_17, __v_18]; 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_63: G = __r_arr[0];
+                let __v_64: G = __r_arr[1];
+                let __v_65: G = (__v_35 + __v_37);
+                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_65]; 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_66: G = __r_arr[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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_67, __v_68, __v_19, __v_20, __v_35, __v_36, __v_66, __v_8, __v_12, __v_36, __v_69]; 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_70: G = __r_arr[0];
+                let __v_71: G = __r_arr[1];
+                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_63, __v_64, __v_61, __v_62]; 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_72: G = __r_arr[0];
+                let __v_73: G = __r_arr[1];
+                let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_72, __v_73, __v_70, __v_71]; 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_74: G = __r_arr[0];
+                let __v_75: G = G::from_u64(1);
+                if (__v_74 != __v_75) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_75.as_canonical_u64() });
+                }
+                let __v_76: G = G::from_u64(1);
+                let __v_77: G = (__v_9 + __v_76);
+                let __v_78: G = (__v_12 + __v_36);
+                let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_34, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_77, __v_38, __v_39, __v_78, __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[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_79: G = __r_arr[0];
+                let __ret: [G; OUT_193] = [__v_79];
+                record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_194: usize = 3;
+const IN_194: usize = 3;
+const OUT_194: usize = 2;
+fn aiur_fn_194(
+  inp: [G; IN_194],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_194], ExecError> {
+  stacker::maybe_grow(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_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(0);
+        let __v_14: G = G::from_u64(0);
+        let __ret: [G; OUT_194] = [__v_13, __v_14];
+        record.function_queries[194].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]; 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_13: G = __r_arr[0];
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_15, __v_16]; 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_17: G = __r_arr[0];
+        let __v_18: G = __r_arr[1];
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_13, __v_14, __v_17, __v_18]; 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 __v_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __ret: [G; OUT_194] = [__v_19, __v_20];
+        record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_195: usize = 7;
+const IN_195: usize = 7;
+const OUT_195: usize = 2;
+fn aiur_fn_195(
+  inp: [G; IN_195],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_195], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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_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() {
+      1u64 => {
+        let __ret: [G; OUT_195] = [__v_0, __v_1];
+        record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_10, __v_11]; 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 __v_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_12, __v_13]; 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_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0, __v_1, __v_14, __v_15]; 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 __v_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_16, __v_17, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !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 = __r_arr[1];
+        let __ret: [G; OUT_195] = [__v_18, __v_19];
+        record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_196: usize = 39;
+const IN_196: usize = 39;
+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 __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];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        match __v_0.as_canonical_u64() {
+          _ => {
+            let __v_39: G = (__v_0 - __v_38);
+            let __v_40: G = G::from_bool((__v_39 == G::ZERO));
+            let __v_41: G = G::from_u64(1);
+            if (__v_40 != __v_41) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64() });
+            }
+            let __v_42: G = (__v_4 - __v_36);
+            let __v_43: G = G::from_bool((__v_42 == G::ZERO));
+            let __v_44: G = G::from_u64(1);
+            if (__v_43 != __v_44) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64() });
+            }
+            let __v_45: G = (__v_5 - __v_37);
+            let __v_46: G = G::from_bool((__v_45 == G::ZERO));
+            let __v_47: G = G::from_u64(1);
+            if (__v_46 != __v_47) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64() });
+            }
+            match __v_12.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_48: G = __r_arr[0];
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !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_49: G = __r_arr[0];
+                match __v_13.as_canonical_u64() {
+                  _ => {
+                    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_9, __v_10]; 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_50: G = __r_arr[0];
+                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_7, __v_12, __v_50, __v_13, __v_14, __v_15, __v_17, __v_35, __v_16]; 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_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 = G::from_u64(0);
+                    let __v_61: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_60, __v_61, __v_35, __v_51, __v_52, __v_53, __v_54]; 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_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(0);
+                    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_48, __v_49, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_64, __v_62, __v_63, __v_65, __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[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_66: G = __r_arr[0];
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !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_67: G = __r_arr[0];
+                    let __v_68: G = G::from_u64(1);
+                    if (__v_67 != __v_68) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64() });
+                    }
+                    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_12]; 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_69: G = __r_arr[0];
+                    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__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_70: G = __r_arr[0];
+                    let __v_71: G = (__v_69 - __v_70);
+                    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() });
+                    }
+                    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_48]; 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_74: G = __r_arr[0];
+                    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_16]; 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_75: G = __r_arr[0];
+                    let __v_76: G = (__v_74 - __v_75);
+                    let __v_77: G = G::from_bool((__v_76 == G::ZERO));
+                    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() });
+                    }
+                    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_48]; 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_79: G = __r_arr[0];
+                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_59, __v_33, __v_34, __v_30, __v_31, __v_32, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_13, __v_14, __v_15, __v_50, __v_48, __v_49, __v_17, __v_57, __v_58, __v_79, __v_0, __v_36, __v_37]; 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_80: G = __r_arr[0];
+                    let __ret: [G; OUT_196] = [__v_80];
+                    record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_197: usize = 1;
+const IN_197: usize = 1;
+const OUT_197: usize = 1;
+fn aiur_fn_197(
+  inp: [G; IN_197],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_197], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    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_197] = [__v_4];
+        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_2 - __v_4);
+        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() });
+        }
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_197] = [__v_8];
+        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_198: usize = 2;
+const IN_198: usize = 2;
+const OUT_198: usize = 1;
+fn aiur_fn_198(
+  inp: [G; IN_198],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_198], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 14] = { let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 14 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 14] = __args[..14].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];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = { let __values: [G; 14] = [__v_16, __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]; let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_198] = [__v_18];
+        record.function_queries[198].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_16: G = __loaded[0];
+        let __v_17: G = __loaded[1];
+        let __v_18: G = __loaded[2];
+        match __v_16.as_canonical_u64() {
+          0u64 => {
+            match __v_17.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_15, __v_18]; 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_19: G = __r_arr[0];
+                let __ret: [G; OUT_198] = [__v_19];
+                record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_19: G = G::from_u64(0);
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_15, __v_18]; 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_20: G = __r_arr[0];
+                let __v_21: G = { let __values: [G; 14] = [__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_20]; let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_198] = [__v_21];
+                record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.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; 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; 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_199] = [__v_8];
+        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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_199] = [__v_9];
+                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_199] = [__v_11];
+                record.function_queries[199].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_200: usize = 1;
+const IN_200: usize = 1;
+const OUT_200: usize = 2;
+fn aiur_fn_200(
+  inp: [G; IN_200],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_200], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_200] = [__v_3, __v_4];
+    record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_201: usize = 2;
+const IN_201: usize = 2;
+const OUT_201: usize = 2;
+fn aiur_fn_201(
+  inp: [G; IN_201],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_201], 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_201] = [__v_4, __v_0];
+        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_5]; 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 __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_201] = [__v_9, __v_7];
+        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 2;
+fn aiur_fn_202(
+  inp: [G; IN_202],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_202], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_202] = [__v_3, __v_4];
+    record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_203: usize = 2;
+const IN_203: usize = 2;
+const OUT_203: usize = 2;
+fn aiur_fn_203(
+  inp: [G; IN_203],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_203], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_203] = [__v_4, __v_0];
+        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_203] = [__v_16, __v_14];
+        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_204: usize = 67;
+const IN_204: usize = 67;
+const OUT_204: usize = 0;
+fn aiur_fn_204(
+  inp: [G; IN_204],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_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 __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 = G::from_u64(0);
+    let __v_68: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_68]; let __info = io_buffer.get_info(__v_67, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_69: G = __io_pair.0;
+    let __v_70: G = __io_pair.1;
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_69]; 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_71: G = __r_arr[0];
+    let __v_72: G = __r_arr[1];
+    let __v_73: G = __r_arr[2];
+    let __v_74: G = __r_arr[3];
+    let __v_75: G = __r_arr[4];
+    let __v_76: G = __r_arr[5];
+    let __v_77: G = __r_arr[6];
+    let __v_78: G = __r_arr[7];
+    let __v_79: G = __r_arr[8];
+    let __v_80: G = __r_arr[9];
+    let __v_81: G = __r_arr[10];
+    let __v_82: G = __r_arr[11];
+    let __v_83: G = __r_arr[12];
+    let __v_84: G = __r_arr[13];
+    let __v_85: G = __r_arr[14];
+    let __v_86: G = __r_arr[15];
+    let __v_87: G = __r_arr[16];
+    let __v_88: G = __r_arr[17];
+    let __v_89: G = __r_arr[18];
+    let __v_90: G = __r_arr[19];
+    let __v_91: G = __r_arr[20];
+    let __v_92: G = __r_arr[21];
+    let __v_93: G = __r_arr[22];
+    let __v_94: G = __r_arr[23];
+    let __v_95: G = G::from_u64(1);
+    let __v_96: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_96]; let __info = io_buffer.get_info(__v_95, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_97: G = __io_pair.0;
+    let __v_98: G = __io_pair.1;
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_97]; 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_99: G = __r_arr[0];
+    let __v_100: G = __r_arr[1];
+    let __v_101: G = __r_arr[2];
+    let __v_102: G = __r_arr[3];
+    let __v_103: G = __r_arr[4];
+    let __v_104: G = __r_arr[5];
+    let __v_105: G = __r_arr[6];
+    let __v_106: G = __r_arr[7];
+    let __v_107: G = __r_arr[8];
+    let __v_108: G = __r_arr[9];
+    let __v_109: G = __r_arr[10];
+    let __v_110: G = __r_arr[11];
+    let __v_111: G = __r_arr[12];
+    let __v_112: G = G::from_u64(2);
+    let __v_113: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_113]; let __info = io_buffer.get_info(__v_112, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_114: G = __io_pair.0;
+    let __v_115: G = __io_pair.1;
+    let __v_116: G = G::from_u64(2);
+    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_116, __v_114, __v_115]; 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_117: G = __r_arr[0];
+    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_117]; 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_118: G = __r_arr[0];
+    let __v_119: G = __r_arr[1];
+    let __v_120: G = (__v_69 + __v_70);
+    if (__v_94 != __v_120) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_120.as_canonical_u64() });
+    }
+    let __v_121: G = G::from_u64(1);
+    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_121, __v_97, __v_98]; 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_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 __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__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_151, __v_152, __v_153]; 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_154: G = __r_arr[0];
+    let __v_155: G = __r_arr[1];
+    let __v_156: G = __r_arr[2];
+    let __v_157: G = __r_arr[3];
+    let __v_158: G = __r_arr[4];
+    let __v_159: G = __r_arr[5];
+    let __v_160: G = __r_arr[6];
+    let __v_161: G = __r_arr[7];
+    let __v_162: G = __r_arr[8];
+    let __v_163: G = __r_arr[9];
+    let __v_164: G = __r_arr[10];
+    let __v_165: G = __r_arr[11];
+    let __v_166: G = __r_arr[12];
+    let __v_167: G = __r_arr[13];
+    let __v_168: G = __r_arr[14];
+    let __v_169: G = __r_arr[15];
+    let __v_170: G = __r_arr[16];
+    let __v_171: G = __r_arr[17];
+    let __v_172: G = __r_arr[18];
+    let __v_173: G = __r_arr[19];
+    let __v_174: G = __r_arr[20];
+    let __v_175: G = __r_arr[21];
+    let __v_176: G = __r_arr[22];
+    let __v_177: G = __r_arr[23];
+    let __v_178: G = __r_arr[24];
+    let __v_179: G = __r_arr[25];
+    let __v_180: G = __r_arr[26];
+    let __v_181: G = __r_arr[27];
+    let __v_182: G = __r_arr[28];
+    let __v_183: G = __r_arr[29];
+    let __v_184: G = __r_arr[30];
+    let __v_185: G = __r_arr[31];
+    if (__v_154 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_0.as_canonical_u64() });
+    }
+    if (__v_155 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_155.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
+    }
+    if (__v_156 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_156.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
+    }
+    if (__v_157 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_157.as_canonical_u64(), rhs: __v_3.as_canonical_u64() });
+    }
+    if (__v_158 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
+    }
+    if (__v_159 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+    }
+    if (__v_160 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
+    }
+    if (__v_161 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
+    }
+    if (__v_162 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
+    }
+    if (__v_163 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_163.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
+    }
+    if (__v_164 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
+    }
+    if (__v_165 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_165.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
+    }
+    if (__v_166 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+    }
+    if (__v_167 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
+    }
+    if (__v_168 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_168.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+    }
+    if (__v_169 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+    }
+    if (__v_170 != __v_16) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
+    }
+    if (__v_171 != __v_17) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
+    }
+    if (__v_172 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
+    }
+    if (__v_173 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
+    }
+    if (__v_174 != __v_20) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
+    }
+    if (__v_175 != __v_21) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_175.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
+    }
+    if (__v_176 != __v_22) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_176.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
+    }
+    if (__v_177 != __v_23) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_177.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+    }
+    if (__v_178 != __v_24) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+    }
+    if (__v_179 != __v_25) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_25.as_canonical_u64() });
+    }
+    if (__v_180 != __v_26) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
+    }
+    if (__v_181 != __v_27) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_27.as_canonical_u64() });
+    }
+    if (__v_182 != __v_28) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_182.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
+    }
+    if (__v_183 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_29.as_canonical_u64() });
+    }
+    if (__v_184 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_30.as_canonical_u64() });
+    }
+    if (__v_185 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_185.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
+    }
+    let __v_186: G = (__v_97 + __v_98);
+    if (__v_111 != __v_186) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_186.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_117]; 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_187: G = __r_arr[0];
+    let __v_188: G = __r_arr[1];
+    let __v_189: G = __r_arr[2];
+    let __v_190: G = __r_arr[3];
+    let __v_191: G = __r_arr[4];
+    let __v_192: G = __r_arr[5];
+    let __v_193: G = __r_arr[6];
+    let __v_194: G = __r_arr[7];
+    let __v_195: G = __r_arr[8];
+    let __v_196: G = __r_arr[9];
+    let __v_197: G = __r_arr[10];
+    let __v_198: G = __r_arr[11];
+    let __v_199: G = __r_arr[12];
+    let __v_200: G = __r_arr[13];
+    let __v_201: G = __r_arr[14];
+    let __v_202: G = __r_arr[15];
+    let __v_203: G = __r_arr[16];
+    let __v_204: G = __r_arr[17];
+    let __v_205: G = __r_arr[18];
+    let __v_206: G = __r_arr[19];
+    let __v_207: G = __r_arr[20];
+    let __v_208: G = __r_arr[21];
+    let __v_209: G = __r_arr[22];
+    let __v_210: G = __r_arr[23];
+    let __v_211: G = __r_arr[24];
+    let __v_212: G = __r_arr[25];
+    let __v_213: G = __r_arr[26];
+    let __v_214: G = __r_arr[27];
+    let __v_215: G = __r_arr[28];
+    let __v_216: G = __r_arr[29];
+    let __v_217: G = __r_arr[30];
+    let __v_218: G = __r_arr[31];
+    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218]; 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_219: G = __r_arr[0];
+    let __v_220: G = __r_arr[1];
+    let __v_221: G = __r_arr[2];
+    let __v_222: G = __r_arr[3];
+    let __v_223: G = __r_arr[4];
+    let __v_224: G = __r_arr[5];
+    let __v_225: G = __r_arr[6];
+    let __v_226: G = __r_arr[7];
+    let __v_227: G = __r_arr[8];
+    let __v_228: G = __r_arr[9];
+    let __v_229: G = __r_arr[10];
+    let __v_230: G = __r_arr[11];
+    let __v_231: G = __r_arr[12];
+    let __v_232: G = __r_arr[13];
+    let __v_233: G = __r_arr[14];
+    let __v_234: G = __r_arr[15];
+    let __v_235: G = __r_arr[16];
+    let __v_236: G = __r_arr[17];
+    let __v_237: G = __r_arr[18];
+    let __v_238: G = __r_arr[19];
+    let __v_239: G = __r_arr[20];
+    let __v_240: G = __r_arr[21];
+    let __v_241: G = __r_arr[22];
+    let __v_242: G = __r_arr[23];
+    let __v_243: G = __r_arr[24];
+    let __v_244: G = __r_arr[25];
+    let __v_245: G = __r_arr[26];
+    let __v_246: G = __r_arr[27];
+    let __v_247: G = __r_arr[28];
+    let __v_248: G = __r_arr[29];
+    let __v_249: G = __r_arr[30];
+    let __v_250: G = __r_arr[31];
+    if (__v_219 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_219.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
+    }
+    if (__v_220 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_33.as_canonical_u64() });
+    }
+    if (__v_221 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_221.as_canonical_u64(), rhs: __v_34.as_canonical_u64() });
+    }
+    if (__v_222 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_222.as_canonical_u64(), rhs: __v_35.as_canonical_u64() });
+    }
+    if (__v_223 != __v_36) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_36.as_canonical_u64() });
+    }
+    if (__v_224 != __v_37) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_224.as_canonical_u64(), rhs: __v_37.as_canonical_u64() });
+    }
+    if (__v_225 != __v_38) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_38.as_canonical_u64() });
+    }
+    if (__v_226 != __v_39) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_226.as_canonical_u64(), rhs: __v_39.as_canonical_u64() });
+    }
+    if (__v_227 != __v_40) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_227.as_canonical_u64(), rhs: __v_40.as_canonical_u64() });
+    }
+    if (__v_228 != __v_41) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_228.as_canonical_u64(), rhs: __v_41.as_canonical_u64() });
+    }
+    if (__v_229 != __v_42) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_229.as_canonical_u64(), rhs: __v_42.as_canonical_u64() });
+    }
+    if (__v_230 != __v_43) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_43.as_canonical_u64() });
+    }
+    if (__v_231 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_231.as_canonical_u64(), rhs: __v_44.as_canonical_u64() });
+    }
+    if (__v_232 != __v_45) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
+    }
+    if (__v_233 != __v_46) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_46.as_canonical_u64() });
+    }
+    if (__v_234 != __v_47) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_234.as_canonical_u64(), rhs: __v_47.as_canonical_u64() });
+    }
+    if (__v_235 != __v_48) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_235.as_canonical_u64(), rhs: __v_48.as_canonical_u64() });
+    }
+    if (__v_236 != __v_49) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_49.as_canonical_u64() });
+    }
+    if (__v_237 != __v_50) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_237.as_canonical_u64(), rhs: __v_50.as_canonical_u64() });
+    }
+    if (__v_238 != __v_51) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_238.as_canonical_u64(), rhs: __v_51.as_canonical_u64() });
+    }
+    if (__v_239 != __v_52) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_239.as_canonical_u64(), rhs: __v_52.as_canonical_u64() });
+    }
+    if (__v_240 != __v_53) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_53.as_canonical_u64() });
+    }
+    if (__v_241 != __v_54) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_54.as_canonical_u64() });
+    }
+    if (__v_242 != __v_55) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_55.as_canonical_u64() });
+    }
+    if (__v_243 != __v_56) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
+    }
+    if (__v_244 != __v_57) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_244.as_canonical_u64(), rhs: __v_57.as_canonical_u64() });
+    }
+    if (__v_245 != __v_58) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_245.as_canonical_u64(), rhs: __v_58.as_canonical_u64() });
+    }
+    if (__v_246 != __v_59) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_246.as_canonical_u64(), rhs: __v_59.as_canonical_u64() });
+    }
+    if (__v_247 != __v_60) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_247.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
+    }
+    if (__v_248 != __v_61) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_248.as_canonical_u64(), rhs: __v_61.as_canonical_u64() });
+    }
+    if (__v_249 != __v_62) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_249.as_canonical_u64(), rhs: __v_62.as_canonical_u64() });
+    }
+    if (__v_250 != __v_63) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_250.as_canonical_u64(), rhs: __v_63.as_canonical_u64() });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_119.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_251: G = __loaded[0];
+    let __v_252: G = __loaded[1];
+    let __v_253: G = __loaded[2];
+    let __v_254: G = G::from_u64(1);
+    let __v_255: G = G::from_u64(1);
+    if (__v_251 != __v_254) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_254.as_canonical_u64() });
+    }
+    if (__v_252 != __v_255) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_255.as_canonical_u64() });
+    }
+    if (__v_253 != __v_255) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_253.as_canonical_u64(), rhs: __v_255.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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]; 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_256: G = __r_arr[0];
+    let __v_257: G = G::from_u64(1);
+    if (__v_256 != __v_257) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_256.as_canonical_u64(), rhs: __v_257.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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_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_118, __v_64, __v_65, __v_66]; 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_258: G = __r_arr[0];
+    let __v_259: G = G::from_u64(1);
+    if (__v_258 != __v_259) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_258.as_canonical_u64(), rhs: __v_259.as_canonical_u64() });
+    }
+    let __ret: [G; OUT_204] = [];
+    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 = 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 __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_205] = [__v_4];
+        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3]; 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_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_205] = [__v_6];
+        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_206: usize = 1;
+const IN_206: usize = 1;
+const OUT_206: usize = 1;
+fn aiur_fn_206(
+  inp: [G; IN_206],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_206], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    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_206] = [__v_4];
+        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_206] = [__v_4];
+        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_207: usize = 2;
+const IN_207: usize = 2;
+const OUT_207: usize = 2;
+fn aiur_fn_207(
+  inp: [G; IN_207],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_207], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __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_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() {
+      0u64 => {
+        let __ret: [G; OUT_207] = [__v_4, __v_5];
+        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_208: usize = 1;
+const IN_208: usize = 1;
+const OUT_208: usize = 8;
+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 __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(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 __ret: [G; OUT_208] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
+        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_10]; 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_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 __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__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 __ret: [G; OUT_208] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_209: usize = 2;
+const IN_209: usize = 2;
+const OUT_209: usize = 12;
+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 __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 __loaded: [G; 14] = { let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; 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: 14 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 14] = __args[..14].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];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_209] = [__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[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_210: usize = 2;
+const IN_210: usize = 2;
+const OUT_210: usize = 1;
+fn aiur_fn_210(
+  inp: [G; IN_210],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_210], 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_216] = { let __args: [G; IN_216] = [__v_0, __v_1]; 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_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() {
+      0u64 => {
+        let __ret: [G; OUT_210] = [__v_4];
+        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.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 __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_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];
+    match __v_1.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 __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_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_211] = [__v_8];
+        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_212: usize = 1;
+const IN_212: usize = 1;
+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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_212] = [__v_5];
+        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4]; 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_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_5 + __v_6);
+        let __ret: [G; OUT_212] = [__v_7];
+        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.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; 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_213] = [__v_1];
+        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_11, __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_13: G = __r_arr[0];
+        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_213] = [__v_14];
+        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_214: usize = 1;
+const IN_214: usize = 1;
+const OUT_214: usize = 8;
+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 __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 __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 __ret: [G; OUT_214] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3]; 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 __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_8] = { let __args: [G; IN_8] = [__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[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__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 __ret: [G; OUT_214] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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 __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_215] = [__v_1];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4, __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_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_215] = [__v_7];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_216] = [__v_0];
+        record.function_queries[216].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_216] = { let __args: [G; IN_216] = [__v_0, __v_3]; 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_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];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_216] = [__v_7];
+            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_217: usize = 1;
+const IN_217: usize = 1;
+const OUT_217: usize = 1;
+fn aiur_fn_217(
+  inp: [G; IN_217],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_217], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    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];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_217] = [__v_8];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_7]; 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 = G::from_u64(1);
+        let __v_10: G = (__v_8 + __v_9);
+        let __ret: [G; OUT_217] = [__v_10];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_218: usize = 1;
+const IN_218: usize = 1;
+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 __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 __ret: [G; OUT_218] = [__v_11];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_10]; 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_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_218] = [__v_13];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_219: usize = 1;
+const IN_219: usize = 1;
+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 __loaded: [G; 14] = { let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 14 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 14] = __args[..14].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];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_15: G = G::from_u64(0);
+        let __ret: [G; OUT_219] = [__v_15];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_14]; 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_15: G = __r_arr[0];
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = (__v_15 + __v_16);
+        let __ret: [G; OUT_219] = [__v_17];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_220: usize = 2;
+const IN_220: usize = 2;
+const OUT_220: usize = 32;
+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 __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0, __v_1]; 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_2: 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_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __v_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];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_220] = [__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];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_221] = [__v_0];
+        record.function_queries[221].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_221] = { let __args: [G; IN_221] = [__v_0, __v_3]; 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_4: G = __r_arr[0];
+        let __loaded: [G; 14] = { let __mq = record.memory_queries.get_mut(&14).ok_or(ExecError::InvalidMemorySize(14))?; 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: 14 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 14] = __args[..14].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];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_221] = [__v_18];
+            record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_222: usize = 2;
+const IN_222: usize = 2;
+const OUT_222: usize = 1;
+fn aiur_fn_222(
+  inp: [G; IN_222],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_222], 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_222] = [__v_0];
+        record.function_queries[222].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_222] = { let __args: [G; IN_222] = [__v_0, __v_3]; 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 __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() {
+          0u64 => {
+            let __ret: [G; OUT_222] = [__v_8];
+            record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+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];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_223] = [__v_0];
+        record.function_queries[223].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_223] = { let __args: [G; IN_223] = [__v_0, __v_3]; 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_4: 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_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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].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];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_223] = [__v_38];
+            record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+pub(crate) fn execute_generated(
+  fun_idx: usize,
+  args: &[G],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+) -> Result<Vec<G>, ExecError> {
+  match fun_idx as u64 {
+    0u64 => {
+      let __inp: [G; IN_0] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_0(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    1u64 => {
+      let __inp: [G; IN_1] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_1(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    2u64 => {
+      let __inp: [G; IN_2] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_2(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    3u64 => {
+      let __inp: [G; IN_3] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_3(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    4u64 => {
+      let __inp: [G; IN_4] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_4(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    5u64 => {
+      let __inp: [G; IN_5] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_5(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    6u64 => {
+      let __inp: [G; IN_6] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_6(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    7u64 => {
+      let __inp: [G; IN_7] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_7(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    8u64 => {
+      let __inp: [G; IN_8] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_8(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    9u64 => {
+      let __inp: [G; IN_9] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_9(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    10u64 => {
+      let __inp: [G; IN_10] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_10(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    11u64 => {
+      let __inp: [G; IN_11] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_11(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    12u64 => {
+      let __inp: [G; IN_12] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_12(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    13u64 => {
+      let __inp: [G; IN_13] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_13(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    14u64 => {
+      let __inp: [G; IN_14] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_14(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    15u64 => {
+      let __inp: [G; IN_15] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_15(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    16u64 => {
+      let __inp: [G; IN_16] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_16(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    17u64 => {
+      let __inp: [G; IN_17] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_17(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    18u64 => {
+      let __inp: [G; IN_18] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_18(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    19u64 => {
+      let __inp: [G; IN_19] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_19(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    20u64 => {
+      let __inp: [G; IN_20] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_20(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    21u64 => {
+      let __inp: [G; IN_21] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_21(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    22u64 => {
+      let __inp: [G; IN_22] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_22(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    23u64 => {
+      let __inp: [G; IN_23] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_23(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    24u64 => {
+      let __inp: [G; IN_24] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_24(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    25u64 => {
+      let __inp: [G; IN_25] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_25(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    26u64 => {
+      let __inp: [G; IN_26] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_26(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    27u64 => {
+      let __inp: [G; IN_27] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_27(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    28u64 => {
+      let __inp: [G; IN_28] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_28(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    29u64 => {
+      let __inp: [G; IN_29] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_29(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    30u64 => {
+      let __inp: [G; IN_30] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_30(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    31u64 => {
+      let __inp: [G; IN_31] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_31(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    32u64 => {
+      let __inp: [G; IN_32] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_32(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    33u64 => {
+      let __inp: [G; IN_33] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_33(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    34u64 => {
+      let __inp: [G; IN_34] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_34(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    35u64 => {
+      let __inp: [G; IN_35] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_35(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    36u64 => {
+      let __inp: [G; IN_36] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_36(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    37u64 => {
+      let __inp: [G; IN_37] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_37(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    38u64 => {
+      let __inp: [G; IN_38] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_38(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    39u64 => {
+      let __inp: [G; IN_39] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_39(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    40u64 => {
+      let __inp: [G; IN_40] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_40(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    41u64 => {
+      let __inp: [G; IN_41] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_41(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    42u64 => {
+      let __inp: [G; IN_42] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_42(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    43u64 => {
+      let __inp: [G; IN_43] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_43(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    44u64 => {
+      let __inp: [G; IN_44] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_44(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    45u64 => {
+      let __inp: [G; IN_45] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_45(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    46u64 => {
+      let __inp: [G; IN_46] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_46(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    47u64 => {
+      let __inp: [G; IN_47] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_47(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    48u64 => {
+      let __inp: [G; IN_48] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_48(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    49u64 => {
+      let __inp: [G; IN_49] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_49(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    50u64 => {
+      let __inp: [G; IN_50] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_50(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    51u64 => {
+      let __inp: [G; IN_51] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_51(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    52u64 => {
+      let __inp: [G; IN_52] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_52(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    53u64 => {
+      let __inp: [G; IN_53] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_53(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    54u64 => {
+      let __inp: [G; IN_54] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_54(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    55u64 => {
+      let __inp: [G; IN_55] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_55(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    56u64 => {
+      let __inp: [G; IN_56] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_56(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    57u64 => {
+      let __inp: [G; IN_57] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_57(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    58u64 => {
+      let __inp: [G; IN_58] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_58(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    59u64 => {
+      let __inp: [G; IN_59] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_59(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    60u64 => {
+      let __inp: [G; IN_60] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_60(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    61u64 => {
+      let __inp: [G; IN_61] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_61(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    62u64 => {
+      let __inp: [G; IN_62] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_62(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    63u64 => {
+      let __inp: [G; IN_63] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_63(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    64u64 => {
+      let __inp: [G; IN_64] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_64(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    65u64 => {
+      let __inp: [G; IN_65] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_65(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    66u64 => {
+      let __inp: [G; IN_66] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_66(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    67u64 => {
+      let __inp: [G; IN_67] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_67(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    68u64 => {
+      let __inp: [G; IN_68] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_68(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    69u64 => {
+      let __inp: [G; IN_69] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_69(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    70u64 => {
+      let __inp: [G; IN_70] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_70(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    71u64 => {
+      let __inp: [G; IN_71] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_71(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    72u64 => {
+      let __inp: [G; IN_72] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_72(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    73u64 => {
+      let __inp: [G; IN_73] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_73(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    74u64 => {
+      let __inp: [G; IN_74] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_74(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    75u64 => {
+      let __inp: [G; IN_75] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_75(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    76u64 => {
+      let __inp: [G; IN_76] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_76(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    77u64 => {
+      let __inp: [G; IN_77] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_77(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    78u64 => {
+      let __inp: [G; IN_78] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_78(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    79u64 => {
+      let __inp: [G; IN_79] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_79(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    80u64 => {
+      let __inp: [G; IN_80] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_80(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    81u64 => {
+      let __inp: [G; IN_81] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_81(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    82u64 => {
+      let __inp: [G; IN_82] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_82(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    83u64 => {
+      let __inp: [G; IN_83] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_83(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    84u64 => {
+      let __inp: [G; IN_84] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_84(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    85u64 => {
+      let __inp: [G; IN_85] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_85(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    86u64 => {
+      let __inp: [G; IN_86] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_86(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    87u64 => {
+      let __inp: [G; IN_87] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_87(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    88u64 => {
+      let __inp: [G; IN_88] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_88(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    89u64 => {
+      let __inp: [G; IN_89] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_89(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    90u64 => {
+      let __inp: [G; IN_90] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_90(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    91u64 => {
+      let __inp: [G; IN_91] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_91(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    92u64 => {
+      let __inp: [G; IN_92] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_92(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    93u64 => {
+      let __inp: [G; IN_93] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_93(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    94u64 => {
+      let __inp: [G; IN_94] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_94(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    95u64 => {
+      let __inp: [G; IN_95] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_95(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    96u64 => {
+      let __inp: [G; IN_96] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_96(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    97u64 => {
+      let __inp: [G; IN_97] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_97(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    98u64 => {
+      let __inp: [G; IN_98] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_98(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    99u64 => {
+      let __inp: [G; IN_99] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_99(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    100u64 => {
+      let __inp: [G; IN_100] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_100(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    101u64 => {
+      let __inp: [G; IN_101] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_101(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    102u64 => {
+      let __inp: [G; IN_102] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_102(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    103u64 => {
+      let __inp: [G; IN_103] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_103(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    104u64 => {
+      let __inp: [G; IN_104] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_104(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    105u64 => {
+      let __inp: [G; IN_105] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_105(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    106u64 => {
+      let __inp: [G; IN_106] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_106(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    107u64 => {
+      let __inp: [G; IN_107] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_107(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    108u64 => {
+      let __inp: [G; IN_108] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_108(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    109u64 => {
+      let __inp: [G; IN_109] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_109(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    110u64 => {
+      let __inp: [G; IN_110] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_110(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    111u64 => {
+      let __inp: [G; IN_111] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_111(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    112u64 => {
+      let __inp: [G; IN_112] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_112(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    113u64 => {
+      let __inp: [G; IN_113] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_113(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    114u64 => {
+      let __inp: [G; IN_114] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_114(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    115u64 => {
+      let __inp: [G; IN_115] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_115(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    116u64 => {
+      let __inp: [G; IN_116] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_116(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    117u64 => {
+      let __inp: [G; IN_117] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_117(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    118u64 => {
+      let __inp: [G; IN_118] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_118(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    119u64 => {
+      let __inp: [G; IN_119] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_119(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    120u64 => {
+      let __inp: [G; IN_120] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_120(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    121u64 => {
+      let __inp: [G; IN_121] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_121(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    122u64 => {
+      let __inp: [G; IN_122] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_122(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    123u64 => {
+      let __inp: [G; IN_123] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_123(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    124u64 => {
+      let __inp: [G; IN_124] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_124(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    125u64 => {
+      let __inp: [G; IN_125] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_125(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    126u64 => {
+      let __inp: [G; IN_126] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_126(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    127u64 => {
+      let __inp: [G; IN_127] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_127(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    128u64 => {
+      let __inp: [G; IN_128] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_128(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    129u64 => {
+      let __inp: [G; IN_129] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_129(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    130u64 => {
+      let __inp: [G; IN_130] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_130(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    131u64 => {
+      let __inp: [G; IN_131] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_131(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    132u64 => {
+      let __inp: [G; IN_132] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_132(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    133u64 => {
+      let __inp: [G; IN_133] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_133(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    134u64 => {
+      let __inp: [G; IN_134] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_134(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    135u64 => {
+      let __inp: [G; IN_135] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_135(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    136u64 => {
+      let __inp: [G; IN_136] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_136(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    137u64 => {
+      let __inp: [G; IN_137] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_137(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    138u64 => {
+      let __inp: [G; IN_138] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_138(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    139u64 => {
+      let __inp: [G; IN_139] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_139(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    140u64 => {
+      let __inp: [G; IN_140] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_140(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    141u64 => {
+      let __inp: [G; IN_141] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_141(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    142u64 => {
+      let __inp: [G; IN_142] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_142(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    143u64 => {
+      let __inp: [G; IN_143] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_143(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    144u64 => {
+      let __inp: [G; IN_144] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_144(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    145u64 => {
+      let __inp: [G; IN_145] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_145(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    146u64 => {
+      let __inp: [G; IN_146] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_146(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    147u64 => {
+      let __inp: [G; IN_147] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_147(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    148u64 => {
+      let __inp: [G; IN_148] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_148(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    149u64 => {
+      let __inp: [G; IN_149] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_149(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    150u64 => {
+      let __inp: [G; IN_150] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_150(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    151u64 => {
+      let __inp: [G; IN_151] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_151(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    152u64 => {
+      let __inp: [G; IN_152] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_152(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    153u64 => {
+      let __inp: [G; IN_153] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_153(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    154u64 => {
+      let __inp: [G; IN_154] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_154(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    155u64 => {
+      let __inp: [G; IN_155] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_155(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    156u64 => {
+      let __inp: [G; IN_156] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_156(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    157u64 => {
+      let __inp: [G; IN_157] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_157(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    158u64 => {
+      let __inp: [G; IN_158] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_158(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    159u64 => {
+      let __inp: [G; IN_159] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_159(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    160u64 => {
+      let __inp: [G; IN_160] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_160(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    161u64 => {
+      let __inp: [G; IN_161] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_161(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    162u64 => {
+      let __inp: [G; IN_162] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_162(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    163u64 => {
+      let __inp: [G; IN_163] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_163(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    164u64 => {
+      let __inp: [G; IN_164] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_164(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    165u64 => {
+      let __inp: [G; IN_165] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_165(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    166u64 => {
+      let __inp: [G; IN_166] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_166(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    167u64 => {
+      let __inp: [G; IN_167] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_167(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    168u64 => {
+      let __inp: [G; IN_168] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_168(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    169u64 => {
+      let __inp: [G; IN_169] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_169(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    170u64 => {
+      let __inp: [G; IN_170] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_170(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    171u64 => {
+      let __inp: [G; IN_171] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_171(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    172u64 => {
+      let __inp: [G; IN_172] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_172(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    173u64 => {
+      let __inp: [G; IN_173] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_173(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    174u64 => {
+      let __inp: [G; IN_174] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_174(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    175u64 => {
+      let __inp: [G; IN_175] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_175(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    176u64 => {
+      let __inp: [G; IN_176] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_176(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    177u64 => {
+      let __inp: [G; IN_177] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_177(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    178u64 => {
+      let __inp: [G; IN_178] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_178(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    179u64 => {
+      let __inp: [G; IN_179] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_179(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    180u64 => {
+      let __inp: [G; IN_180] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_180(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    181u64 => {
+      let __inp: [G; IN_181] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_181(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    182u64 => {
+      let __inp: [G; IN_182] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_182(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    183u64 => {
+      let __inp: [G; IN_183] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_183(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    184u64 => {
+      let __inp: [G; IN_184] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_184(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    185u64 => {
+      let __inp: [G; IN_185] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_185(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    186u64 => {
+      let __inp: [G; IN_186] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_186(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    187u64 => {
+      let __inp: [G; IN_187] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_187(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    188u64 => {
+      let __inp: [G; IN_188] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_188(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    189u64 => {
+      let __inp: [G; IN_189] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_189(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    190u64 => {
+      let __inp: [G; IN_190] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_190(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    191u64 => {
+      let __inp: [G; IN_191] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_191(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    192u64 => {
+      let __inp: [G; IN_192] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_192(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    193u64 => {
+      let __inp: [G; IN_193] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_193(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    194u64 => {
+      let __inp: [G; IN_194] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_194(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    195u64 => {
+      let __inp: [G; IN_195] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_195(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    196u64 => {
+      let __inp: [G; IN_196] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_196(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    197u64 => {
+      let __inp: [G; IN_197] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_197(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    198u64 => {
+      let __inp: [G; IN_198] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_198(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    199u64 => {
+      let __inp: [G; IN_199] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_199(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    200u64 => {
+      let __inp: [G; IN_200] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_200(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    201u64 => {
+      let __inp: [G; IN_201] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_201(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    202u64 => {
+      let __inp: [G; IN_202] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_202(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    203u64 => {
+      let __inp: [G; IN_203] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_203(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    204u64 => {
+      let __inp: [G; IN_204] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_204(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    205u64 => {
+      let __inp: [G; IN_205] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_205(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    206u64 => {
+      let __inp: [G; IN_206] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_206(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    207u64 => {
+      let __inp: [G; IN_207] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_207(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    208u64 => {
+      let __inp: [G; IN_208] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_208(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    209u64 => {
+      let __inp: [G; IN_209] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_209(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    210u64 => {
+      let __inp: [G; IN_210] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_210(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    211u64 => {
+      let __inp: [G; IN_211] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_211(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    212u64 => {
+      let __inp: [G; IN_212] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_212(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    213u64 => {
+      let __inp: [G; IN_213] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_213(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    214u64 => {
+      let __inp: [G; IN_214] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_214(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    215u64 => {
+      let __inp: [G; IN_215] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_215(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    216u64 => {
+      let __inp: [G; IN_216] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_216(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    217u64 => {
+      let __inp: [G; IN_217] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_217(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    218u64 => {
+      let __inp: [G; IN_218] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_218(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    219u64 => {
+      let __inp: [G; IN_219] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_219(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    220u64 => {
+      let __inp: [G; IN_220] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_220(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    221u64 => {
+      let __inp: [G; IN_221] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_221(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    222u64 => {
+      let __inp: [G; IN_222] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_222(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    223u64 => {
+      let __inp: [G; IN_223] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_223(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    _ => {
+      return Err(ExecError::InvalidFunIdx(fun_idx));
+    },
+  }
+}
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
new file mode 100644
index 000000000..720fce56f
--- /dev/null
+++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
@@ -0,0 +1,73 @@
+//! MultiStark-native execute path.
+//!
+//! Parallel to `aiur::execute::Toplevel::execute`, but routes the
+//! Aiur fn invocation through the codegen'd Rust recursive verifier
+//! (`crate::aiur_multi_stark::execute_generated`) instead of the
+//! interpreter. Mirror of `aiur_ixvm_runner` for the MultiStark
+//! toplevel — same `QueryRecord` shape, same multiplicity rules,
+//! same memory and IO side effects, so the trace produced here is
+//! byte-for-byte identical to the interpreter's (modulo the
+//! `execute_generated` codegen's correctness, which is the standing
+//! parity invariant).
+//!
+//! Also home to `verifier_io_buffer`, the native builder for
+//! `verify_multi_stark_proof`'s IO advice — replaces the Lean-side
+//! `MultiStark.verifierInput` buffer construction, which boxed every
+//! proof/vk/claims byte into a Lean `G` and marshalled the whole
+//! buffer across FFI.
+
+use multi_stark::p3_field::PrimeCharacteristicRing;
+use rustc_hash::FxHashMap;
+
+use crate::aiur_multi_stark::execute_generated;
+use aiur::G;
+use aiur::bytecode::{FunIdx, Toplevel};
+use aiur::execute::{ExecError, IOBuffer, IOKeyInfo, QueryRecord};
+
+/// Mirror of `Toplevel::execute` (same return shape, same
+/// `entry`-flag gate), but routes execution through the codegen'd
+/// Rust verifier. Deep recursion is handled via per-fn
+/// `stacker::maybe_grow` checks in the generated code.
+// `args: Vec<G>` mirrors `Toplevel::execute`'s signature so this fn
+// can be used as an `impl Fn(&Toplevel, _, Vec<G>, _) -> _` in
+// `AiurSystem::prove_ixvm` — a `&[G]` here would break that bound.
+#[allow(clippy::needless_pass_by_value)]
+pub fn execute_multi_stark(
+  toplevel: &Toplevel,
+  fun_idx: FunIdx,
+  args: Vec<G>,
+  io_buffer: &mut IOBuffer,
+) -> Result<(QueryRecord, Vec<G>), ExecError> {
+  if !toplevel.functions[fun_idx].entry {
+    return Err(ExecError::NotEntryFunction(fun_idx));
+  }
+  let mut record = QueryRecord::new(toplevel);
+  let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?;
+  Ok((record, output))
+}
+
+/// Build `verify_multi_stark_proof`'s IO advice directly from the raw
+/// byte blobs: channel 0 = proof, 1 = vk, 2 = claims, each registered
+/// under key `[0]` on its channel (one stream per channel). Mirrors
+/// the layout of `MultiStark.verifierInput` (`Ix/MultiStark.lean`).
+pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer {
+  // Measurement hook: dump the raw advice blobs for offline analysis
+  // (vk encoding/activation studies) when IX_DUMP_RECURSION_IO is set
+  // to a directory.
+  if let Ok(dir) = std::env::var("IX_DUMP_RECURSION_IO") {
+    let _ = std::fs::write(format!("{dir}/proof.bin"), proof);
+    let _ = std::fs::write(format!("{dir}/vk.bin"), vk);
+    let _ = std::fs::write(format!("{dir}/claims.bin"), claims);
+  }
+  let mut io =
+    IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() };
+  for (channel, bytes) in
+    [(0u64, proof), (1, vk), (2, claims)].map(|(c, b)| (G::from_u64(c), b))
+  {
+    let data: Vec<G> = bytes.iter().map(|b| G::from_u8(*b)).collect();
+    let len = data.len();
+    io.data.insert(channel, data);
+    io.map.insert((channel, vec![G::ZERO]), IOKeyInfo { idx: 0, len });
+  }
+  io
+}
diff --git a/crates/ixvm-codegen/src/lib.rs b/crates/ixvm-codegen/src/lib.rs
index fb1b2aaa1..6a3ca75e1 100644
--- a/crates/ixvm-codegen/src/lib.rs
+++ b/crates/ixvm-codegen/src/lib.rs
@@ -1,8 +1,11 @@
-//! IxVM-specific Rust glue: codegen'd kernel, native runner, witness
-//! builder. Bridges the `aiur` proving framework with `ixon` /
-//! `ix-common` content-addressed env types.
+//! IxVM-specific Rust glue: codegen'd kernel + codegen'd MultiStark
+//! recursive verifier, their native runners, witness builders.
+//! Bridges the `aiur` proving framework with `ixon` / `ix-common`
+//! content-addressed env types.
 
 pub mod aiur_ixvm;
 pub mod aiur_ixvm_runner;
 pub mod aiur_ixvm_witness;
+pub mod aiur_multi_stark;
+pub mod aiur_multi_stark_runner;
 pub mod env_handle;