diff --git a/Ix/Aiur/Compiler.lean b/Ix/Aiur/Compiler.lean
index ae2503994..d85266632 100644
--- a/Ix/Aiur/Compiler.lean
+++ b/Ix/Aiur/Compiler.lean
@@ -112,6 +112,7 @@ def Bytecode.Toplevel.needsCircuit (t : Bytecode.Toplevel) : Array Bool := Id.ru
 
 /-- Full compilation pipeline. -/
 def Source.Toplevel.compile (t : Source.Toplevel) : Except String CompiledToplevel := do
+  let t ← t.inlineCalls
   let typedDecls ← t.checkAndSimplify.mapError toString
   let concDecls ← typedDecls.concretize.mapError toString
   let (bytecodeRaw, preNameMap) ← concDecls.toBytecode
@@ -129,13 +130,14 @@ def Source.Toplevel.compile (t : Source.Toplevel) : Except String CompiledToplev
 `needsCircuit`, the field-setter `mapIdx`, the name-map `fold`, and the
 terminating `pure` — are all total). -/
 theorem Source.Toplevel.compile_ok_of_stages
-    {t : Source.Toplevel} {typedDecls concDecls bytecodeRaw preNameMap}
-    (hts : t.checkAndSimplify = .ok typedDecls)
+    {t inlined : Source.Toplevel} {typedDecls concDecls bytecodeRaw preNameMap}
+    (hinline : t.inlineCalls = .ok inlined)
+    (hts : inlined.checkAndSimplify = .ok typedDecls)
     (hconc : typedDecls.concretize = .ok concDecls)
     (hbc : concDecls.toBytecode = .ok (bytecodeRaw, preNameMap)) :
     ∃ ct, t.compile = .ok ct := by
-  simp only [Source.Toplevel.compile, hts, hconc, hbc, Except.mapError, bind,
-             Except.bind, pure, Except.pure]
+  simp only [Source.Toplevel.compile, hinline, hts, hconc, hbc, Except.mapError,
+             bind, Except.bind, pure, Except.pure]
   exact ⟨_, rfl⟩
 
 /-- Inverse of `compile_ok_of_stages`: unpack a successful `compile` into
@@ -144,27 +146,28 @@ lemmas through the composition. -/
 theorem Source.Toplevel.compile_stages_of_ok
     {t : Source.Toplevel} {ct : CompiledToplevel}
     (_hct : t.compile = .ok ct) :
-    ∃ typedDecls concDecls bytecodeRaw preNameMap,
-      t.checkAndSimplify = .ok typedDecls ∧
+    ∃ inlined typedDecls concDecls bytecodeRaw preNameMap,
+      t.inlineCalls = .ok inlined ∧
+      inlined.checkAndSimplify = .ok typedDecls ∧
       typedDecls.concretize = .ok concDecls ∧
       concDecls.toBytecode = .ok (bytecodeRaw, preNameMap) := by
   -- Case on each stage result; `mapError` on `.ok` is definitionally `.ok`.
-  cases hts : t.checkAndSimplify with
-  | error e => simp [Source.Toplevel.compile, hts, bind, Except.bind, Except.mapError] at _hct
-  | ok typedDecls =>
-    cases hconc : typedDecls.concretize with
-    | error e =>
-      simp [Source.Toplevel.compile, hts, hconc, bind, Except.bind, Except.mapError] at _hct
-    | ok concDecls =>
-      cases hbc : concDecls.toBytecode with
+  cases hinline : t.inlineCalls with
+  | error e => simp [Source.Toplevel.compile, hinline, bind, Except.bind] at _hct
+  | ok inlined =>
+    cases hts : inlined.checkAndSimplify with
+    | error e => simp [Source.Toplevel.compile, hinline, hts, bind, Except.bind, Except.mapError] at _hct
+    | ok typedDecls =>
+      cases hconc : typedDecls.concretize with
       | error e =>
-        simp [Source.Toplevel.compile, hts, hconc, hbc, bind, Except.bind, Except.mapError] at _hct
-      | ok bc =>
-        obtain ⟨bytecodeRaw, preNameMap⟩ := bc
-        -- `checkAndSimplify`/`concretize` are unfolded; `toBytecode` is not
-        -- (private module), so the first two equalities reduce to `rfl` but
-        -- the third still mentions `concDecls.toBytecode` — supply `hbc`.
-        exact ⟨typedDecls, concDecls, bytecodeRaw, preNameMap, rfl, hconc, hbc⟩
+        simp [Source.Toplevel.compile, hinline, hts, hconc, bind, Except.bind, Except.mapError] at _hct
+      | ok concDecls =>
+        cases hbc : concDecls.toBytecode with
+        | error e =>
+          simp [Source.Toplevel.compile, hinline, hts, hconc, hbc, bind, Except.bind, Except.mapError] at _hct
+        | ok bc =>
+          obtain ⟨bytecodeRaw, preNameMap⟩ := bc
+          exact ⟨inlined, typedDecls, concDecls, bytecodeRaw, preNameMap, rfl, hts, hconc, hbc⟩
 
 -- Compile post-conditions moved to `Proofs/StructCompatible.lean`.
 
diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean
index a42a4dd46..2066a8b43 100644
--- a/Ix/Aiur/Compiler/Check.lean
+++ b/Ix/Aiur/Compiler/Check.lean
@@ -622,7 +622,14 @@ def inferTerm (t : Term) : CheckM Typed.Term := match t with
     match typOpt with
     | some (typ, escapes) => pure (Typed.Term.match typ escapes term' branches')
     | none => throw .emptyMatch
-  | .app func args u => do
+  | .app func args mode => do
+    -- `.inlined` is eliminated by `Toplevel.inlineCalls` before checking;
+    -- reaching it here means the pass was skipped. Downstream stages carry
+    -- only the unconstrained flag.
+    let u : Bool ← match mode with
+      | .normal => pure false
+      | .unconstrained => pure true
+      | .inlined => throw (.cannotApply func)
     let ctx ← read
     -- Local function lookup (only for unqualified names); returns
     -- `some (.ok …)` on hit, `some (.error …)` on wrong-type local, `none` to
diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index 19d6a05f5..d7ad59013 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -156,6 +156,10 @@ syntax ("." noWs)? ident "(" ")"                                              :
 syntax ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")"                  : aiur_trm
 syntax "#" noWs ("." noWs)? ident "(" ")"                                     : aiur_trm
 syntax "#" noWs ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")"         : aiur_trm
+-- Inlined call: `@fn(args)` splices `fn`'s body into the caller at compile
+-- time (no separate circuit). Callee must not be inline-recursive.
+syntax "@" noWs ("." noWs)? ident "(" ")"                                     : aiur_trm
+syntax "@" noWs ("." noWs)? ident "(" aiur_trm (", " aiur_trm)* ")"         : aiur_trm
 syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "(" ")"                      : aiur_trm
 syntax ident "‹" aiur_typ (", " aiur_typ)* "›" "(" aiur_trm
        (", " aiur_trm)* ")"                                                  : aiur_trm
@@ -266,16 +270,22 @@ partial def elabTrm : ElabStxCat `aiur_trm
     | .str .anonymous _ => pure ()
     | _ => logWarningAt f "empty parentheses are not needed; use the name without parentheses"
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| $[.]?$f:ident ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| #$[.]?$f:ident()) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.unconstrained]
   | `(aiur_trm| #$[.]?$f:ident($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.unconstrained]
+  | `(aiur_trm| @$[.]?$f:ident()) => do
+    let g ← mkAppM ``Global.mk #[toExpr f.getId]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.inlined]
+  | `(aiur_trm| @$[.]?$f:ident($a:aiur_trm $[, $as:aiur_trm]*)) => do
+    let g ← mkAppM ``Global.mk #[toExpr f.getId]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.inlined]
   | `(aiur_trm| $a:aiur_trm + $b:aiur_trm) => do
     mkAppM ``Source.Term.add #[← elabTrm a, ← elabTrm b]
   | `(aiur_trm| $a:aiur_trm - $b:aiur_trm) => do
@@ -355,29 +365,29 @@ partial def elabTrm : ElabStxCat `aiur_trm
   -- Template function calls: explicit type args are dropped (inferred)
   | `(aiur_trm| $f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›()) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| $f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›
                  ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| #$f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›()) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.unconstrained]
   | `(aiur_trm| #$f:ident‹$_:aiur_typ $[, $_:aiur_typ]*›
                  ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let g ← mkAppM ``Global.mk #[toExpr f.getId]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr true]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.unconstrained]
   -- Template constructor calls
   | `(aiur_trm| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident()) => do
     logWarningAt ctor "empty parentheses are not needed; use the name without parentheses"
     let name := tmpl.getId ++ ctor.getId
     let g ← mkAppM ``Global.mk #[toExpr name]
-    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabEmptyList ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| $tmpl:ident‹$_:aiur_typ $[, $_:aiur_typ]*›.$ctor:ident
                  ($a:aiur_trm $[, $as:aiur_trm]*)) => do
     let name := tmpl.getId ++ ctor.getId
     let g ← mkAppM ``Global.mk #[toExpr name]
-    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, toExpr false]
+    mkAppM ``Source.Term.app #[g, ← elabList a as elabTrm ``Source.Term, mkConst ``Source.CallMode.normal]
   | `(aiur_trm| fold($i .. $j, $init, |$acc, @$v| $body)) => do
     let i := i.getNat
     let j := j.getNat
diff --git a/Ix/Aiur/Stages/Source.lean b/Ix/Aiur/Stages/Source.lean
index 1e548b2b4..cbc8ca4fe 100644
--- a/Ix/Aiur/Stages/Source.lean
+++ b/Ix/Aiur/Stages/Source.lean
@@ -374,6 +374,21 @@ inductive Pattern
 
 namespace Source
 
+/-- How a function application is compiled.
+* `normal` — a constrained circuit call (its own circuit, a lookup, and
+  output columns at the call site).
+* `unconstrained` — a call whose callee is trusted (no lookup / circuit
+  constraint); the old `unconstrained := true`.
+* `inlined` — the callee's body is spliced into the caller at compile
+  time (no separate circuit, no interface columns). Eliminated by
+  `Toplevel.inlineCalls` before typechecking; forbidden for callees that
+  are (transitively) inline-recursive. -/
+inductive CallMode
+  | normal
+  | unconstrained
+  | inlined
+  deriving Repr, BEq, Hashable, Inhabited, DecidableEq
+
 /-- Stage 1 term language. `tuple` and `array` are direct constructors (no `Data`
 mutual child); cf. `Ix/Aiur/Term.lean` which nested them under `.data`. -/
 inductive Term
@@ -386,7 +401,7 @@ inductive Term
   | ret : Term → Term
   | let : Pattern → Term → Term → Term
   | match : Term → List (Pattern × Term) → Term
-  | app : Global → List Term → (unconstrained : Bool) → Term
+  | app : Global → List Term → (mode : CallMode) → Term
   | add : Term → Term → Term
   | sub : Term → Term → Term
   | mul : Term → Term → Term
@@ -539,6 +554,487 @@ where
         result := result.push item
     pure (globals, result)
 
+/-- Rename every local bound in a pattern to a fresh `.str "inl#N"` name,
+extending `subst` for the pattern's scope and advancing the fresh counter.
+-/
+def Pattern.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
+    Pattern → Nat × Std.HashMap Local Local × Pattern
+  | .var x =>
+    let x' : Local := .str s!"inl#{cnt}"
+    (cnt + 1, subst.insert x x', .var x')
+  | .wildcard => (cnt, subst, .wildcard)
+  | .field g => (cnt, subst, .field g)
+  | .ref g ps =>
+    let (cnt, subst, ps') := ps.attach.foldl (init := (cnt, subst, ([] : List Pattern)))
+      fun (cnt, subst, acc) ⟨p, _⟩ =>
+        let (cnt, subst, p') := Pattern.freshen cnt subst p
+        (cnt, subst, acc ++ [p'])
+    (cnt, subst, .ref g ps')
+  | .tuple ps =>
+    let (cnt, subst, ps') := ps.attach.foldl (init := (cnt, subst, (#[] : Array Pattern)))
+      fun (cnt, subst, acc) ⟨p, _⟩ =>
+        let (cnt, subst, p') := Pattern.freshen cnt subst p
+        (cnt, subst, acc.push p')
+    (cnt, subst, .tuple ps')
+  | .array ps =>
+    let (cnt, subst, ps') := ps.attach.foldl (init := (cnt, subst, (#[] : Array Pattern)))
+      fun (cnt, subst, acc) ⟨p, _⟩ =>
+        let (cnt, subst, p') := Pattern.freshen cnt subst p
+        (cnt, subst, acc.push p')
+    (cnt, subst, .array ps')
+  | .or p q =>
+    let (cnt, subst, p') := Pattern.freshen cnt subst p
+    let (cnt, subst, q') := Pattern.freshen cnt subst q
+    (cnt, subst, .or p' q')
+  | .pointer p =>
+    let (cnt, subst, p') := Pattern.freshen cnt subst p
+    (cnt, subst, .pointer p')
+termination_by p => sizeOf p
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Consistently α-rename the locals bound inside `t` to fresh names,
+following `subst` for the currently-renamed variables. Used before
+splicing an inlined body so its locals cannot collide with the caller's
+(the `Simple` pass floats nested `let`s outward, which would otherwise
+capture reused names). Only bound occurrences are rewritten; free
+variables that are the callee's inputs are handled by `subst` seeded at
+the call site. -/
+def Term.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
+    Term → Nat × Term :=
+  fun t =>
+  match t with
+  | .var x => (cnt, .var (subst.getD x x))
+  | .unit | .ref _ | .field _ | .u8Lit _ => (cnt, t)
+  | .let p v b =>
+    let (cnt, v') := Term.freshen cnt subst v
+    let (cnt, subst', p') := Pattern.freshen cnt subst p
+    let (cnt, b') := Term.freshen cnt subst' b
+    (cnt, .let p' v' b')
+  | .match s arms =>
+    let (cnt, s') := Term.freshen cnt subst s
+    let (cnt, arms') := arms.attach.foldl (init := (cnt, ([] : List (Pattern × Term))))
+      fun (cnt, acc) ⟨(p, a), _⟩ =>
+        let (cnt, subst', p') := Pattern.freshen cnt subst p
+        let (cnt, a') := Term.freshen cnt subst' a
+        (cnt, acc ++ [(p', a')])
+    (cnt, .match s' arms')
+  | .tuple ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) fun (cnt, acc) ⟨x, _⟩ =>
+      let (cnt, x') := Term.freshen cnt subst x; (cnt, acc.push x')
+    (cnt, .tuple ts')
+  | .array ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[])) fun (cnt, acc) ⟨x, _⟩ =>
+      let (cnt, x') := Term.freshen cnt subst x; (cnt, acc.push x')
+    (cnt, .array ts')
+  | .app g args mode =>
+    let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term))) fun (cnt, acc) ⟨x, _⟩ =>
+      let (cnt, x') := Term.freshen cnt subst x; (cnt, acc ++ [x'])
+    (cnt, .app g args' mode)
+  | .ret a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ret a')
+  | .add a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .add a' b')
+  | .sub a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .sub a' b')
+  | .mul a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .mul a' b')
+  | .eqZero a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .eqZero a')
+  | .proj a n => let (cnt, a') := Term.freshen cnt subst a; (cnt, .proj a' n)
+  | .get a n => let (cnt, a') := Term.freshen cnt subst a; (cnt, .get a' n)
+  | .slice a i j => let (cnt, a') := Term.freshen cnt subst a; (cnt, .slice a' i j)
+  | .set a n v => let (cnt, a') := Term.freshen cnt subst a; let (cnt, v') := Term.freshen cnt subst v; (cnt, .set a' n v')
+  | .store a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .store a')
+  | .load a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .load a')
+  | .ptrVal a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ptrVal a')
+  | .ann τ a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ann τ a')
+  | .assertEq a b c =>
+    let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; let (cnt, c') := Term.freshen cnt subst c
+    (cnt, .assertEq a' b' c')
+  | .ioGetInfo c k => let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; (cnt, .ioGetInfo c' k')
+  | .ioSetInfo c k i l rv =>
+    let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; let (cnt, i') := Term.freshen cnt subst i
+    let (cnt, l') := Term.freshen cnt subst l; let (cnt, rv') := Term.freshen cnt subst rv
+    (cnt, .ioSetInfo c' k' i' l' rv')
+  | .ioRead c i n => let (cnt, c') := Term.freshen cnt subst c; let (cnt, i') := Term.freshen cnt subst i; (cnt, .ioRead c' i' n)
+  | .ioWrite c d rv =>
+    let (cnt, c') := Term.freshen cnt subst c; let (cnt, d') := Term.freshen cnt subst d; let (cnt, rv') := Term.freshen cnt subst rv
+    (cnt, .ioWrite c' d' rv')
+  | .u8BitDecomposition a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8BitDecomposition a')
+  | .u8ShiftLeft a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8ShiftLeft a')
+  | .u8ShiftRight a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .u8ShiftRight a')
+  | .u8Xor a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Xor a' b')
+  | .u8Add a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Add a' b')
+  | .u8Mul a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Mul a' b')
+  | .u8Sub a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Sub a' b')
+  | .u8And a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8And a' b')
+  | .u8Or a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8Or a' b')
+  | .u8LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8LessThan a' b')
+  | .u32LessThan a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u32LessThan a' b')
+  | .u8ChainRotr7 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8ChainRotr7 a' b')
+  | .u8ChainRotr4 a b => let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .u8ChainRotr4 a' b')
+  | .unconstrainedBigUintDivMod a b =>
+    let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; (cnt, .unconstrainedBigUintDivMod a' b')
+  | .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')
+  | .debug s o a =>
+    let (cnt, o') := match o with
+      | none => (cnt, none)
+      | some x => let (cnt, x') := Term.freshen cnt subst x; (cnt, some x')
+    let (cnt, a') := Term.freshen cnt subst a
+    (cnt, .debug s o' a')
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Peel the leading `let` bindings off a term: returns the binding frames
+(outermost first) and the non-`let` core. -/
+def Term.peelLets : Term → List (Pattern × Term) × Term
+  | .let p v b => let (fs, c) := Term.peelLets b; ((p, v) :: fs, c)
+  | t => ([], t)
+
+/-- Wrap `body` in a chain of `let` frames (first frame outermost). -/
+def Term.wrapLets : List (Pattern × Term) → Term → Term
+  | [], body => body
+  | (p, v) :: fs, body => .let p v (Term.wrapLets fs body)
+
+/-- Every `.inlined` call site in `t`, as `(callee, argCount)` pairs. Drives
+both validation (callee exists, arity matches) and the inline-dependency
+graph the bottom-up expansion is ordered by. -/
+def Term.inlineCallSites : Term → List (Global × Nat)
+  | .app g args .inlined =>
+    args.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) [(g, args.length)]
+  | .app _ args _ =>
+    args.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) []
+  | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => []
+  | .tuple ts | .array ts =>
+    ts.attach.foldl (fun acc ⟨a, _⟩ => acc ++ a.inlineCallSites) []
+  | .match s arms =>
+    arms.attach.foldl (fun acc ⟨(_, a), _⟩ => acc ++ a.inlineCallSites) s.inlineCallSites
+  | .let _ v b => v.inlineCallSites ++ b.inlineCallSites
+  | .add a b | .sub a b | .mul a b | .set 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
+  | .unconstrainedBigUintDivMod a b | .u8RangeCheck a b | .ioGetInfo a b =>
+    a.inlineCallSites ++ b.inlineCallSites
+  | .assertEq a b c | .ioWrite a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites
+  | .ioSetInfo c k i l rv =>
+    c.inlineCallSites ++ k.inlineCallSites ++ i.inlineCallSites ++ l.inlineCallSites ++ rv.inlineCallSites
+  | .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
+  | .debug _ o a => (match o with | none => [] | some x => x.inlineCallSites) ++ a.inlineCallSites
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Structurally splice every `.app g args .inlined` in `t`, given `done`,
+which maps each already-expanded callee to its input locals and its (already
+inline-free) body. At an inline site the callee's inputs and body are
+α-renamed to fresh `inl#N` names (`Term.freshen`, seeded with the inputs),
+then each fresh input is bound to its argument via a `let`. Freshening the
+inputs BEFORE binding the arguments is essential: arguments are caller terms,
+so a fresh input name cannot shadow a caller local an argument references (nor
+collide across copies).
+
+Bottom-up ordering (see `Toplevel.inlineCalls`) guarantees `done[g]` is
+already inline-free, so the spliced body is NOT re-traversed — the recursion
+is purely structural on `t` and needs no fuel. `cnt` threads the fresh-name
+counter. If `done` lacks `g` the site is left untouched; the ordering makes
+that unreachable. -/
+def Term.expandOnce (done : Std.HashMap Global (List Local × Term)) (cnt : Nat) :
+    Term → Nat × Term := fun t => match t with
+  | .app g args .inlined =>
+    let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term)))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [a'])
+    match done[g]? with
+    | none => (cnt, .app g args' .inlined)
+    | some (ins, body) =>
+      let (cnt, subst, freshInputs) := ins.foldl
+        (init := (cnt, (∅ : Std.HashMap Local Local), ([] : List Local)))
+        fun (cnt, subst, acc) inp =>
+          let inp' : Local := .str s!"inl#{cnt}"
+          (cnt + 1, subst.insert inp inp', acc ++ [inp'])
+      let (cnt, freshBody) := Term.freshen cnt subst body
+      -- A branching callee ends in a `match`. In a strict argument position
+      -- the splice's leading lets hoist out (`Term.hoistLets`) but the match
+      -- core would stay put, which lowering rejects as a non-tail match in
+      -- arbitrary position. Bind the match to a fresh local so hoisting
+      -- leaves only a variable behind; in let-RHS/tail positions the extra
+      -- binding is harmless.
+      let (cnt, freshBody) :=
+        match Term.peelLets freshBody with
+        | (fs, core@(.match ..)) =>
+          let out : Local := .str s!"inl#{cnt}"
+          (cnt + 1, Term.wrapLets fs (.let (.var out) core (.var out)))
+        | _ => (cnt, freshBody)
+      (cnt, (freshInputs.zip args').foldr
+        (fun (input, arg) acc => Term.let (.var input) arg acc) freshBody)
+  | .app g args mode =>
+    let (cnt, args') := args.attach.foldl (init := (cnt, ([] : List Term)))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [a'])
+    (cnt, .app g args' mode)
+  | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => (cnt, t)
+  | .tuple ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[]))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc.push a')
+    (cnt, .tuple ts')
+  | .array ts =>
+    let (cnt, ts') := ts.attach.foldl (init := (cnt, #[]))
+      fun (cnt, acc) ⟨a, _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc.push a')
+    (cnt, .array ts')
+  | .match s arms =>
+    let (cnt, s') := Term.expandOnce done cnt s
+    let (cnt, arms') := arms.attach.foldl (init := (cnt, ([] : List (Pattern × Term))))
+      fun (cnt, acc) ⟨(p, a), _⟩ => let (cnt, a') := Term.expandOnce done cnt a; (cnt, acc ++ [(p, a')])
+    (cnt, .match s' arms')
+  | .let p v b =>
+    let (cnt, v') := Term.expandOnce done cnt v
+    let (cnt, b') := Term.expandOnce done cnt b
+    (cnt, .let p v' b')
+  | .ret a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ret a')
+  | .add a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .add a' b')
+  | .sub a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .sub a' b')
+  | .mul a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .mul a' b')
+  | .eqZero a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .eqZero a')
+  | .proj a n => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .proj a' n)
+  | .get a n => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .get a' n)
+  | .slice a i j => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .slice a' i j)
+  | .set a n v => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, v') := Term.expandOnce done cnt v; (cnt, .set a' n v')
+  | .store a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .store a')
+  | .load a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .load a')
+  | .ptrVal a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ptrVal a')
+  | .ann τ a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ann τ a')
+  | .assertEq a b c =>
+    let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b
+    let (cnt, c') := Term.expandOnce done cnt c; (cnt, .assertEq a' b' c')
+  | .ioGetInfo c k => let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k; (cnt, .ioGetInfo c' k')
+  | .ioSetInfo c k i l rv =>
+    let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k
+    let (cnt, i') := Term.expandOnce done cnt i; let (cnt, l') := Term.expandOnce done cnt l
+    let (cnt, rv') := Term.expandOnce done cnt rv; (cnt, .ioSetInfo c' k' i' l' rv')
+  | .ioRead c i n => let (cnt, c') := Term.expandOnce done cnt c; let (cnt, i') := Term.expandOnce done cnt i; (cnt, .ioRead c' i' n)
+  | .ioWrite c d rv =>
+    let (cnt, c') := Term.expandOnce done cnt c; let (cnt, d') := Term.expandOnce done cnt d
+    let (cnt, rv') := Term.expandOnce done cnt rv; (cnt, .ioWrite c' d' rv')
+  | .u8BitDecomposition a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8BitDecomposition a')
+  | .u8ShiftLeft a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8ShiftLeft a')
+  | .u8ShiftRight a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .u8ShiftRight a')
+  | .u8Xor a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Xor a' b')
+  | .u8Add a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Add a' b')
+  | .u8Mul a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Mul a' b')
+  | .u8Sub a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Sub a' b')
+  | .u8And a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8And a' b')
+  | .u8Or a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8Or a' b')
+  | .u8LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8LessThan a' b')
+  | .u32LessThan a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u32LessThan a' b')
+  | .u8ChainRotr7 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8ChainRotr7 a' b')
+  | .u8ChainRotr4 a b => let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .u8ChainRotr4 a' b')
+  | .unconstrainedBigUintDivMod a b =>
+    let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b; (cnt, .unconstrainedBigUintDivMod a' b')
+  | .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')
+  | .debug s o a =>
+    let (cnt, o') := match o with
+      | none => (cnt, none)
+      | some x => let (cnt, x') := Term.expandOnce done cnt x; (cnt, some x')
+    let (cnt, a') := Term.expandOnce done cnt a
+    (cnt, .debug s o' a')
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Peel leading lets off each of `ts` (already hoisted), collecting the
+frames left-to-right so evaluation order is preserved, and returning the
+frame chain plus the cores. -/
+def Term.peelListLets (ts : List Term) : List (Pattern × Term) × List Term :=
+  ts.foldr
+    (fun t (fs, cs) => let (f, c) := Term.peelLets t; (f ++ fs, c :: cs))
+    ([], [])
+
+def Term.peelArrayLets (ts : Array Term) : List (Pattern × Term) × Array Term :=
+  let (fs, cs) := Term.peelListLets ts.toList
+  (fs, cs.toArray)
+
+/-- Hoist every `let`-chain out of a strict argument position into a
+wrapping `let`. Inlining splices a callee body (a `let`-chain ending in a
+value) wherever the `@`-call appeared; in a `let`-RHS or tail position the
+`Simple` pass already floats those lets outward, but in an argument
+position (a `set`/array element, an operator operand, …) they would stay
+nested, which the lowering cannot handle. This normalizes all such
+positions. `let`-RHS, `match` arm bodies, and `ret`/`debug` continuations
+are already handled downstream, so their lets are left in place. -/
+def Term.hoistLets : Term → Term :=
+  fun t =>
+  -- Hoist a construct's argument terms: peel each arg's lets and wrap.
+  match t with
+  | .unit | .var _ | .ref _ | .field _ | .u8Lit _ => t
+  | .let p v b => .let p (Term.hoistLets v) (Term.hoistLets b)
+  | .match s arms =>
+    let (fs, sc) := Term.peelLets (Term.hoistLets s)
+    Term.wrapLets fs (.match sc (arms.attach.map fun ⟨(p, a), _⟩ => (p, Term.hoistLets a)))
+  | .ret a => .ret (Term.hoistLets a)
+  | .debug s o a =>
+    .debug s (match o with | none => none | some x => some (Term.hoistLets x)) (Term.hoistLets a)
+  | .tuple ts =>
+    let (fs, cs) := Term.peelArrayLets (ts.attach.map fun ⟨x, _⟩ => Term.hoistLets x)
+    Term.wrapLets fs (.tuple cs)
+  | .array ts =>
+    let (fs, cs) := Term.peelArrayLets (ts.attach.map fun ⟨x, _⟩ => Term.hoistLets x)
+    Term.wrapLets fs (.array cs)
+  | .app g args mode =>
+    let (fs, cs) := Term.peelListLets (args.attach.map fun ⟨x, _⟩ => Term.hoistLets x)
+    Term.wrapLets fs (.app g cs mode)
+  | .assertEq a b c =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c]
+    match cs with
+    | [a, b, c] => Term.wrapLets fs (.assertEq a b c)
+    | _ => t
+  | .ioSetInfo a b c d e =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c, Term.hoistLets d, Term.hoistLets e]
+    match cs with
+    | [a, b, c, d, e] => Term.wrapLets fs (.ioSetInfo a b c d e)
+    | _ => t
+  | .ioWrite a b c =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c]
+    match cs with
+    | [a, b, c] => Term.wrapLets fs (.ioWrite a b c)
+    | _ => t
+  | .ioGetInfo a b =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+    match cs with | [a, b] => Term.wrapLets fs (.ioGetInfo a b) | _ => t
+  | .ioRead a b n =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+    match cs with | [a, b] => Term.wrapLets fs (.ioRead a b n) | _ => t
+  | .add a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                match cs with | [a, b] => Term.wrapLets fs (.add a b) | _ => t
+  | .sub a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                match cs with | [a, b] => Term.wrapLets fs (.sub a b) | _ => t
+  | .mul a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                match cs with | [a, b] => Term.wrapLets fs (.mul a b) | _ => t
+  | .eqZero a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.eqZero c)
+  | .proj a n => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.proj c n)
+  | .get a n => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.get c n)
+  | .slice a i j => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.slice c i j)
+  | .set a n v =>
+    let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets v]
+    match cs with | [a, v] => Term.wrapLets fs (.set a n v) | _ => t
+  | .store a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.store c)
+  | .load a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.load c)
+  | .ptrVal a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.ptrVal c)
+  | .ann τ a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.ann τ c)
+  | .u8BitDecomposition a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8BitDecomposition c)
+  | .u8ShiftLeft a => let (fs, c) := Term.peelLets (Term.hoistLets a); Term.wrapLets fs (.u8ShiftLeft c)
+  | .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)
+  | .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]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8Add a b) | _ => t
+  | .u8Mul a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8Mul a b) | _ => t
+  | .u8Sub a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8Sub a b) | _ => t
+  | .u8And a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                  match cs with | [a, b] => Term.wrapLets fs (.u8And a b) | _ => t
+  | .u8Or a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                 match cs with | [a, b] => Term.wrapLets fs (.u8Or a b) | _ => t
+  | .u8LessThan a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                       match cs with | [a, b] => Term.wrapLets fs (.u8LessThan a b) | _ => t
+  | .u32LessThan a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                        match cs with | [a, b] => Term.wrapLets fs (.u32LessThan a b) | _ => t
+  | .u8ChainRotr7 a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                         match cs with | [a, b] => Term.wrapLets fs (.u8ChainRotr7 a b) | _ => t
+  | .u8ChainRotr4 a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                         match cs with | [a, b] => Term.wrapLets fs (.u8ChainRotr4 a b) | _ => t
+  | .unconstrainedBigUintDivMod a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                                       match cs with | [a, b] => Term.wrapLets fs (.unconstrainedBigUintDivMod a b) | _ => t
+  | .u8RangeCheck a b => let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b]
+                         match cs with | [a, b] => Term.wrapLets fs (.u8RangeCheck a b) | _ => t
+termination_by t => sizeOf t
+decreasing_by
+  all_goals first
+    | decreasing_tactic
+    | (have := Array.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+    | (have := List.sizeOf_lt_of_mem ‹_ ∈ _›; grind)
+
+/-- Kahn-style topological sort of the inline-dependency graph: each pass
+emits every function whose inline-callees are already emitted, so callees
+precede callers. `rounds` bounds the number of passes by the function count
+— a DAG on N nodes has depth < N, so N passes suffice — which is the honest
+structural termination measure (not an arbitrary fuel cap). A non-empty
+remaining set with no ready function is an inline cycle and is rejected. -/
+def inlineTopo (deps : Std.HashMap Global (List Global)) :
+    Nat → List Global → Std.HashSet Global → List Global → Except String (List Global)
+  | 0, remaining, _, acc =>
+    if remaining.isEmpty then pure acc
+    else throw "inline recursion: dependency graph did not converge"
+  | rounds + 1, remaining, emitted, acc =>
+    match remaining with
+    | [] => pure acc
+    | _ =>
+      let (ready, notReady) := remaining.partition fun g =>
+        (deps.getD g []).all emitted.contains
+      match ready with
+      | [] =>
+        throw s!"inline recursion among: {remaining.map Global.toName}"
+      | _ =>
+        let emitted := ready.foldl (fun s g => s.insert g) emitted
+        inlineTopo deps rounds notReady emitted (acc ++ ready)
+termination_by rounds _ _ _ => rounds
+
+/-- Inline-expand every function body in the toplevel, eliminating all
+`.inlined` applications. Run before typechecking.
+
+Bottom-up and fuel-free: `.inlined` calls form a DAG (cycles are rejected as
+inline recursion), so functions are expanded in topological order — every
+callee is fully expanded before any caller inlines it. Each body is therefore
+expanded exactly once (`Term.expandOnce`, structurally recursive on the term),
+and its already-inline-free result is memoized in `done` and spliced (with
+α-renaming) at every call site. -/
+def Toplevel.inlineCalls (t : Toplevel) : Except String Toplevel := do
+  let funcs : Std.HashMap Global Function :=
+    t.functions.foldl (fun m f => m.insert f.name f) ∅
+  -- Inline dependencies per function, validating callee existence and arity.
+  let deps : Std.HashMap Global (List Global) ← t.functions.foldlM (init := ∅)
+    fun deps f => do
+      let gs ← f.body.inlineCallSites.foldlM (init := ([] : List Global))
+        fun acc (g, n) => do
+          let some callee := funcs[g]?
+            | throw s!"inline call to unknown function `{g.toName}`"
+          if n != callee.inputs.length then
+            throw s!"inline `{g.toName}`: got {n} args, expects {callee.inputs.length}"
+          pure (acc ++ [g])
+      pure (deps.insert f.name gs)
+  -- Topological order (callees first). `funcs.size` rounds bound the passes.
+  let names := t.functions.toList.map Function.name
+  let order ← inlineTopo deps names.length names ∅ []
+  -- Expand each body once, in order, memoizing the inline-free result.
+  let done : Std.HashMap Global (List Local × Term) := order.foldl (init := ∅)
+    fun done g =>
+      match funcs[g]? with
+      | none => done
+      | some f => done.insert g (f.inputs.map Prod.fst, (f.body.expandOnce done 0).2)
+  -- Rebuild each function with its expanded body, then hoist argument-position
+  -- lets that splicing may have introduced.
+  let functions := t.functions.map fun f =>
+    match done[f.name]? with
+    | none => f
+    | some (_, body) => { f with body := body.hoistLets }
+  pure { t with functions }
+
 inductive Declaration
   | function : Function → Declaration
   | dataType : DataType → Declaration
diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean
index 7c1061c26..1648bc12d 100644
--- a/Ix/IxVM/Blake3.lean
+++ b/Ix/IxVM/Blake3.lean
@@ -300,108 +300,14 @@ def blake3 := ⟦
     x: [U8; 4],
     y: [U8; 4]
   ) -> [[U8; 4]; 4] {
-    -- a = (a + b) + x
-    let (r1_0, r1_c1) = u8_add(a[0], b[0]);
-    let (r1_s1, r1_o1) = u8_add(a[1], b[1]);
-    let (r1_1, r1_c1a) = u8_add(r1_s1, r1_c1);
-    let r1_c2 = u8_from_field_unsafe(to_field(r1_o1) + to_field(r1_c1a));
-    let (r1_s2, r1_o2) = u8_add(a[2], b[2]);
-    let (r1_2, r1_c2a) = u8_add(r1_s2, r1_c2);
-    let r1_c3 = u8_from_field_unsafe(to_field(r1_o2) + to_field(r1_c2a));
-    let (r1_s3, _z) = u8_add(a[3], b[3]);
-    let (r1_3, _z) = u8_add(r1_s3, r1_c3);
-    let (a0, r2_c1) = u8_add(r1_0, x[0]);
-    let (r2_s1, r2_o1) = u8_add(r1_1, x[1]);
-    let (a1, r2_c1a) = u8_add(r2_s1, r2_c1);
-    let r2_c2 = u8_from_field_unsafe(to_field(r2_o1) + to_field(r2_c1a));
-    let (r2_s2, r2_o2) = u8_add(r1_2, x[2]);
-    let (a2, r2_c2a) = u8_add(r2_s2, r2_c2);
-    let r2_c3 = u8_from_field_unsafe(to_field(r2_o2) + to_field(r2_c2a));
-    let (r2_s3, _z) = u8_add(r1_3, x[3]);
-    let (a3, _z) = u8_add(r2_s3, r2_c3);
-    let a = [a0, a1, a2, a3];
-
-    let d0 = u8_xor(d[0], a[0]);
-    let d1 = u8_xor(d[1], a[1]);
-    let d2 = u8_xor(d[2], a[2]);
-    let d3 = u8_xor(d[3], a[3]);
-    let d = [d2, d3, d0, d1]; -- Right-rotated 16
-
-    -- c = c + d
-    let (nc0, r3_c1) = u8_add(c[0], d[0]);
-    let (r3_s1, r3_o1) = u8_add(c[1], d[1]);
-    let (nc1, r3_c1a) = u8_add(r3_s1, r3_c1);
-    let r3_c2 = u8_from_field_unsafe(to_field(r3_o1) + to_field(r3_c1a));
-    let (r3_s2, r3_o2) = u8_add(c[2], d[2]);
-    let (nc2, r3_c2a) = u8_add(r3_s2, r3_c2);
-    let r3_c3 = u8_from_field_unsafe(to_field(r3_o2) + to_field(r3_c2a));
-    let (r3_s3, _z) = u8_add(c[3], d[3]);
-    let (nc3, _z) = u8_add(r3_s3, r3_c3);
-    let c = [nc0, nc1, nc2, nc3];
-
-    let b0 = u8_xor(b[0], c[0]);
-    let b1 = u8_xor(b[1], c[1]);
-    let b2 = u8_xor(b[2], c[2]);
-    let b3 = u8_xor(b[3], c[3]);
-    -- Right-rotated 12 = rotr8 (byte move) ∘ rotr4 (chained gadget).
-    -- rotr8 of [b0,b1,b2,b3] is [b1,b2,b3,b0]; rotr4 over that pairs (b1,b2)
-    -- and (b3,b0). Two gadget lookups + two free field adds.
-    let (e0, e1, e2) = u8_chain_rotr4(b1, b2);
-    let (f0, f1, f2) = u8_chain_rotr4(b3, b0);
-    -- Combined parts occupy disjoint bit positions: sum is a byte, add as `G`.
-    let b = [e0, u8_from_field_unsafe(to_field(e1) + to_field(f2)), f0,
-             u8_from_field_unsafe(to_field(f1) + to_field(e2))]; -- Right-rotated 12
-
-    -- a = (a + b) + y
-    let (r4_0, r4_c1) = u8_add(a[0], b[0]);
-    let (r4_s1, r4_o1) = u8_add(a[1], b[1]);
-    let (r4_1, r4_c1a) = u8_add(r4_s1, r4_c1);
-    let r4_c2 = u8_from_field_unsafe(to_field(r4_o1) + to_field(r4_c1a));
-    let (r4_s2, r4_o2) = u8_add(a[2], b[2]);
-    let (r4_2, r4_c2a) = u8_add(r4_s2, r4_c2);
-    let r4_c3 = u8_from_field_unsafe(to_field(r4_o2) + to_field(r4_c2a));
-    let (r4_s3, _z) = u8_add(a[3], b[3]);
-    let (r4_3, _z) = u8_add(r4_s3, r4_c3);
-    let (a0, r5_c1) = u8_add(r4_0, y[0]);
-    let (r5_s1, r5_o1) = u8_add(r4_1, y[1]);
-    let (a1, r5_c1a) = u8_add(r5_s1, r5_c1);
-    let r5_c2 = u8_from_field_unsafe(to_field(r5_o1) + to_field(r5_c1a));
-    let (r5_s2, r5_o2) = u8_add(r4_2, y[2]);
-    let (a2, r5_c2a) = u8_add(r5_s2, r5_c2);
-    let r5_c3 = u8_from_field_unsafe(to_field(r5_o2) + to_field(r5_c2a));
-    let (r5_s3, _z) = u8_add(r4_3, y[3]);
-    let (a3, _z) = u8_add(r5_s3, r5_c3);
-    let a = [a0, a1, a2, a3];
-
-    let d0 = u8_xor(d[0], a[0]);
-    let d1 = u8_xor(d[1], a[1]);
-    let d2 = u8_xor(d[2], a[2]);
-    let d3 = u8_xor(d[3], a[3]);
-    let d = [d1, d2, d3, d0]; -- Right-rotated 8
-
-    -- c = c + d
-    let (nc0, r6_c1) = u8_add(c[0], d[0]);
-    let (r6_s1, r6_o1) = u8_add(c[1], d[1]);
-    let (nc1, r6_c1a) = u8_add(r6_s1, r6_c1);
-    let r6_c2 = u8_from_field_unsafe(to_field(r6_o1) + to_field(r6_c1a));
-    let (r6_s2, r6_o2) = u8_add(c[2], d[2]);
-    let (nc2, r6_c2a) = u8_add(r6_s2, r6_c2);
-    let r6_c3 = u8_from_field_unsafe(to_field(r6_o2) + to_field(r6_c2a));
-    let (r6_s3, _z) = u8_add(c[3], d[3]);
-    let (nc3, _z) = u8_add(r6_s3, r6_c3);
-    let c = [nc0, nc1, nc2, nc3];
-
-    let b0 = u8_xor(b[0], c[0]);
-    let b1 = u8_xor(b[1], c[1]);
-    let b2 = u8_xor(b[2], c[2]);
-    let b3 = u8_xor(b[3], c[3]);
-    -- Right-rotated 7 via the chained gadget: pairs (b0,b1) and (b2,b3),
-    -- two lookups + two free field adds.
-    let (g0, g1, g2) = u8_chain_rotr7(b0, b1);
-    let (h0, h1, h2) = u8_chain_rotr7(b2, b3);
-    let b = [g0, u8_from_field_unsafe(to_field(g1) + to_field(h2)), h0,
-             u8_from_field_unsafe(to_field(h1) + to_field(g2))]; -- Right-rotated 7
-
+    let a = @u32_add(@u32_add(a, b), x);
+    let d = @u32_rotr16(@u32_xor(d, a));
+    let c = @u32_add(c, d);
+    let b = @u32_rotr12(@u32_xor(b, c));
+    let a = @u32_add(@u32_add(a, b), y);
+    let d = @u32_rotr8(@u32_xor(d, a));
+    let c = @u32_add(c, d);
+    let b = @u32_rotr7(@u32_xor(b, c));
     [a, b, c, d]
   }
 
diff --git a/Ix/IxVM/ByteStream.lean b/Ix/IxVM/ByteStream.lean
index 8ed8c3456..4fa485e77 100644
--- a/Ix/IxVM/ByteStream.lean
+++ b/Ix/IxVM/ByteStream.lean
@@ -86,6 +86,35 @@ def byteStream := ⟦
     [c0, c1, c2, c3]
   }
 
+  -- Right-rotations of a little-endian word. rotr16 / rotr8 are pure byte
+  -- moves (free); rotr12 / rotr7 are a byte move composed with the chained
+  -- 4-/7-bit gadget (two lookups + two free field adds each).
+  fn u32_rotr16(w: [U8; 4]) -> [U8; 4] {
+    let [w0, w1, w2, w3] = w;
+    [w2, w3, w0, w1]
+  }
+
+  fn u32_rotr8(w: [U8; 4]) -> [U8; 4] {
+    let [w0, w1, w2, w3] = w;
+    [w1, w2, w3, w0]
+  }
+
+  fn u32_rotr12(w: [U8; 4]) -> [U8; 4] {
+    let [w0, w1, w2, w3] = w;
+    let (e0, e1, e2) = u8_chain_rotr4(w1, w2);
+    let (f0, f1, f2) = u8_chain_rotr4(w3, w0);
+    [e0, u8_from_field_unsafe(to_field(e1) + to_field(f2)), f0,
+     u8_from_field_unsafe(to_field(f1) + to_field(e2))]
+  }
+
+  fn u32_rotr7(w: [U8; 4]) -> [U8; 4] {
+    let [w0, w1, w2, w3] = w;
+    let (g0, g1, g2) = u8_chain_rotr7(w0, w1);
+    let (h0, h1, h2) = u8_chain_rotr7(w2, w3);
+    [g0, u8_from_field_unsafe(to_field(g1) + to_field(h2)), h0,
+     u8_from_field_unsafe(to_field(h1) + to_field(g2))]
+  }
+
   -- Byte-by-byte `u64` equality
   fn u64_eq(a: U64, b: U64) -> G {
     let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
diff --git a/Tests/Aiur/Aiur.lean b/Tests/Aiur/Aiur.lean
index 8a6eeb1df..a19ab7229 100644
--- a/Tests/Aiur/Aiur.lean
+++ b/Tests/Aiur/Aiur.lean
@@ -791,6 +791,70 @@ def toplevel := ⟦
     r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10
     + r11 + r12 + r13 + r14 + r15 + r16 + r17 + r18 + r19 + r20 + r21
   }
+
+  ---------------------------------------------------------------------------
+  -- Inlined function calls (`@fn(args)`)
+  --
+  -- An `@`-call splices the callee's body into the caller's circuit: no
+  -- separate circuit, no call interface. These cases cover the splice in
+  -- every position lowering treats specially (let-RHS, strict argument
+  -- slots), plus alpha-renaming, nesting, branching callees, gadget
+  -- lookups joining the caller, and mixing inlined with normal calls.
+  ---------------------------------------------------------------------------
+
+  fn inl_double(x: G) -> G {
+    let t = x + x;
+    t
+  }
+
+  fn inl_sq(x: G) -> G { x * x }
+
+  -- Callee that itself @-inlines another helper (nested splice)
+  fn inl_sq_plus(x: G, y: G) -> G { @inl_sq(x) + y }
+
+  -- Multi-output callee
+  fn inl_pair(x: G) -> (G, G) { (x + 1, x * 2) }
+
+  -- Branching callee: tail match spliced into a let-RHS position
+  fn inl_sign(x: G) -> G {
+    match x {
+      0 => 0,
+      _ => 1,
+    }
+  }
+
+  -- Gadget lookup inside the callee
+  fn inl_add8(a: U8, b: U8) -> (U8, U8) { u8_add(a, b) }
+
+  -- Single aggregate entry: every scenario in one circuit/proof.
+  pub fn inline_test() -> G {
+    -- Basic splice
+    let r1 = @inl_double(21);                     -- 42
+    -- Nested splice (callee @-inlines another helper)
+    let r2 = @inl_sq_plus(3, 4);                  -- 13
+    -- Capture safety: caller binds `t` (the callee's local name) and the
+    -- argument mentions it
+    let t = 5;
+    let r3 = @inl_double(t + 1) + t;              -- 17
+    -- Strict positions: array elements, operator operands, call argument
+    let arr = [@inl_double(3), @inl_sq(3)];       -- [6, 9]
+    let r4 = arr[0] + arr[1] * 100;               -- 906
+    let r5 = @inl_double(3) + @inl_sq(3);         -- 15
+    let r6 = id(@inl_double(7));                  -- 14
+    -- Multi-output callee
+    let (p1, p2) = @inl_pair(5);                  -- (6, 10)
+    let r7 = p1 + p2 * 100;                       -- 1006
+    -- Branching callee in operand position, both paths (the spliced match
+    -- gets bound to a fresh local before hoisting)
+    let r8 = @inl_sign(0) + @inl_sign(5) * 100;   -- 100
+    -- Same callee inlined and normally called: the normal call keeps its
+    -- own circuit + lookup, the inlined one joins this circuit
+    let r9 = @inl_sq(3) + inl_sq(4);              -- 25
+    -- Gadget lookup in the callee joins this circuit
+    let (s, c) = @inl_add8(200u8, 100u8);         -- (44, 1)
+    let r10 = to_field(s) + to_field(c) * 1000;   -- 1044
+    r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10
+  }
 ⟧
 
 def aiurTestCases : List AiurTestCase := [
@@ -948,6 +1012,9 @@ def aiurTestCases : List AiurTestCase := [
 
     -- Non-tail match: all patterns in one proof (incl. function-call scrutinee)
     .noIO `non_tail_match #[] #[2593],
+
+    -- Inlined function calls (`@fn(args)`): all scenarios in one proof
+    .noIO `inline_test #[] #[3182],
   ]
 
 end
diff --git a/Tests/Aiur/Cross.lean b/Tests/Aiur/Cross.lean
index e318b88df..fe9a3252d 100644
--- a/Tests/Aiur/Cross.lean
+++ b/Tests/Aiur/Cross.lean
@@ -1072,6 +1072,41 @@ def toplevel : Source.Toplevel := ⟦
     r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10
     + r11 + r12 + r13 + r14 + r15 + r16 + r17 + r18 + r19 + r20 + r21
   }
+
+  -- Inlined function calls (`@fn(args)`): both evaluators execute an
+  -- inlined call exactly like a normal one, so source/bytecode agreement
+  -- checks the splice (alpha-renaming, nesting, strict-position hoisting,
+  -- branching callees) preserved the semantics.
+  fn inl_sq(x: G) -> G { x * x }
+
+  fn inl_sq_plus(x: G, y: G) -> G { @inl_sq(x) + y }
+
+  fn inl_sign(x: G) -> G {
+    match x {
+      0 => 0,
+      _ => 1,
+    }
+  }
+
+  -- Single aggregate entry: every scenario in one agreement run.
+  pub fn inline_test() -> G {
+    -- Basic splice
+    let r1 = @inl_sq(5) + 1;                      -- 26
+    -- Nested splice (callee @-inlines another helper)
+    let r2 = @inl_sq_plus(3, 4);                  -- 13
+    -- Capture safety: caller local named like a callee binding, argument
+    -- mentions it
+    let t = 5;
+    let r3 = @inl_sq(t + 1) + t;                  -- 41
+    -- Strict positions: operator operands
+    let r4 = @inl_sq(3) + @inl_sq(4) * 100;       -- 1609
+    -- Branching callee in operand position, both paths (the spliced match
+    -- gets bound to a fresh local before hoisting)
+    let r5 = @inl_sign(0) + @inl_sign(7) * 100;   -- 100
+    -- Same callee inlined and normally called
+    let r6 = @inl_sq(3) + inl_sq(4);              -- 25
+    r1 + r2 + r3 + r4 + r5 + r6
+  }
 ⟧
 
 /-- Generic helper: run both evaluators on `entryName` with `inputs` as
@@ -1329,7 +1364,9 @@ def tests : TestSeq :=
   runAgreement "fibonacci(6)" "fibonacci" [6] ++
   -- End-to-end non-tail match entry aggregating many ntm_* helpers
   runAgreement "ntm_recursive_test" "ntm_recursive_test" [] ++
-  runAgreement "non_tail_match" "non_tail_match" []
+  runAgreement "non_tail_match" "non_tail_match" [] ++
+  -- Inlined function calls (`@fn(args)`): all scenarios in one entry
+  runAgreement "inline_test" "inline_test" []
 
 end AiurTests.Cross
 
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index dbacd80c1..a753a6ac0 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -1560,15 +1560,115 @@ fn aiur_fn_5(
   })
 }
 
-const INPUT_SIZE_6: usize = 16;
-const IN_6: usize = 16;
-const OUT_6: usize = 1;
+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 __ret: [G; OUT_6] = [__v_2, __v_3, __v_0, __v_1];
+    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 __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];
+    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_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_9: usize = 4;
+const IN_9: usize = 4;
+const OUT_9: usize = 4;
+fn aiur_fn_9(
+  inp: [G; IN_9],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_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 __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_9] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_10: usize = 16;
+const IN_10: usize = 16;
+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];
@@ -1611,85 +1711,85 @@ fn aiur_fn_6(
                                 match __v_23.as_canonical_u64() {
                                   0u64 => {
                                     let __v_24: G = G::from_u64(1);
-                                    let __ret: [G; OUT_6] = [__v_24];
-                                    record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_10] = [__v_24];
+                                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_24: G = G::from_u64(0);
-                                    let __ret: [G; OUT_6] = [__v_24];
-                                    record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_10] = [__v_24];
+                                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_24: G = G::from_u64(0);
-                                let __ret: [G; OUT_6] = [__v_24];
-                                record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_10] = [__v_24];
+                                record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_24: G = G::from_u64(0);
-                            let __ret: [G; OUT_6] = [__v_24];
-                            record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_10] = [__v_24];
+                            record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_24: G = G::from_u64(0);
-                        let __ret: [G; OUT_6] = [__v_24];
-                        record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_10] = [__v_24];
+                        record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_24: G = G::from_u64(0);
-                    let __ret: [G; OUT_6] = [__v_24];
-                    record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_10] = [__v_24];
+                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_24: G = G::from_u64(0);
-                let __ret: [G; OUT_6] = [__v_24];
-                record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_10] = [__v_24];
+                record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(0);
-            let __ret: [G; OUT_6] = [__v_24];
-            record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_10] = [__v_24];
+            record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_24: G = G::from_u64(0);
-        let __ret: [G; OUT_6] = [__v_24];
-        record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_10] = [__v_24];
+        record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_7: usize = 16;
-const IN_7: usize = 16;
-const OUT_7: usize = 9;
-fn aiur_fn_7(
-  inp: [G; IN_7],
+const INPUT_SIZE_11: usize = 16;
+const IN_11: usize = 16;
+const OUT_11: usize = 9;
+fn aiur_fn_11(
+  inp: [G; IN_11],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_7], 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];
@@ -1759,21 +1859,21 @@ fn aiur_fn_7(
     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_7] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_8: usize = 16;
-const IN_8: usize = 16;
-const OUT_8: usize = 8;
-fn aiur_fn_8(
-  inp: [G; IN_8],
+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_8], 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];
@@ -1795,12 +1895,12 @@ fn aiur_fn_8(
     let __v_16: G = __r_arr[0];
     match __v_16.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_8] = [__v_0, __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));
+        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_13] = { let __args: [G; IN_13] = [__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[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 __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];
@@ -1809,7 +1909,7 @@ fn aiur_fn_8(
         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_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 __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];
@@ -1818,7 +1918,7 @@ fn aiur_fn_8(
         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_8] = { let __args: [G; IN_8] = [__v_17, __v_18, __v_19, __v_20, __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[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 __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];
@@ -1827,8 +1927,8 @@ fn aiur_fn_8(
         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_8] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
-        record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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);
       },
       _ => {
@@ -1838,15 +1938,15 @@ fn aiur_fn_8(
   })
 }
 
-const INPUT_SIZE_9: usize = 2;
-const IN_9: usize = 2;
-const OUT_9: usize = 1;
-fn aiur_fn_9(
-  inp: [G; IN_9],
+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_9], 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];
@@ -1855,37 +1955,37 @@ fn aiur_fn_9(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_9] = [__v_2];
-            record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_9] = [__v_2];
-            record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_9] = [__v_2];
-        record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_13] = [__v_2];
+        record.function_queries[13].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 = 8;
-fn aiur_fn_10(
-  inp: [G; IN_10],
+const INPUT_SIZE_14: usize = 8;
+const IN_14: usize = 8;
+const OUT_14: usize = 8;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_10], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1919,8 +2019,8 @@ fn aiur_fn_10(
                                     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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -1933,8 +2033,8 @@ fn aiur_fn_10(
                                     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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -1948,8 +2048,8 @@ fn aiur_fn_10(
                                 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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1962,8 +2062,8 @@ fn aiur_fn_10(
                             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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -1975,8 +2075,8 @@ fn aiur_fn_10(
                         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_10] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -1987,8 +2087,8 @@ fn aiur_fn_10(
                     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_10] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -1998,8 +2098,8 @@ fn aiur_fn_10(
                 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_10] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -2008,8 +2108,8 @@ fn aiur_fn_10(
             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_10] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -2017,23 +2117,23 @@ fn aiur_fn_10(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 + __v_8);
-        let __ret: [G; OUT_10] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_11: usize = 10;
-const IN_11: usize = 10;
-const OUT_11: usize = 8;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+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_11], 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];
@@ -2073,21 +2173,21 @@ fn aiur_fn_11(
     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_11] = [__v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_12, __v_10];
-    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_12: usize = 8;
-const IN_12: usize = 8;
-const OUT_12: usize = 4;
-fn aiur_fn_12(
-  inp: [G; IN_12],
+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_12], ExecError> {
+) -> 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];
@@ -2120,21 +2220,21 @@ fn aiur_fn_12(
     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_12] = [__v_22, __v_17, __v_12, __v_8];
-    record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_13: usize = 8;
-const IN_13: usize = 8;
-const OUT_13: usize = 8;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+const INPUT_SIZE_17: usize = 8;
+const IN_17: usize = 8;
+const OUT_17: usize = 8;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_13], 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];
@@ -2168,8 +2268,8 @@ fn aiur_fn_13(
                                     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_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2182,8 +2282,8 @@ fn aiur_fn_13(
                                     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_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                 }
@@ -2197,8 +2297,8 @@ fn aiur_fn_13(
                                 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_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -2211,8 +2311,8 @@ fn aiur_fn_13(
                             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_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -2224,8 +2324,8 @@ fn aiur_fn_13(
                         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_13] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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));
                         return Ok(__ret);
                       },
                     }
@@ -2236,8 +2336,8 @@ fn aiur_fn_13(
                     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_13] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -2247,8 +2347,8 @@ fn aiur_fn_13(
                 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_13] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -2257,8 +2357,8 @@ fn aiur_fn_13(
             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_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -2266,23 +2366,23 @@ fn aiur_fn_13(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 - __v_8);
-        let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_14: usize = 8;
-const IN_14: usize = 8;
-const OUT_14: usize = 1;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_18: usize = 8;
+const IN_18: usize = 8;
+const OUT_18: usize = 1;
+fn aiur_fn_18(
+  inp: [G; IN_18],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], 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];
@@ -2314,21 +2414,21 @@ fn aiur_fn_14(
     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_14] = [__v_26];
-    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_18] = [__v_26];
+    record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_15: usize = 0;
-const IN_15: usize = 0;
-const OUT_15: usize = 32;
-fn aiur_fn_15(
-  inp: [G; IN_15],
+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_15], ExecError> {
+) -> 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);
@@ -2338,7 +2438,7 @@ fn aiur_fn_15(
     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_17] = { let __args: [G; IN_17] = [__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 __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];
@@ -2371,21 +2471,21 @@ fn aiur_fn_15(
     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_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_16: usize = 1;
-const IN_16: usize = 1;
-const OUT_16: usize = 1;
-fn aiur_fn_16(
-  inp: [G; IN_16],
+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_16], ExecError> {
+) -> 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);
@@ -2397,7 +2497,7 @@ fn aiur_fn_16(
     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_17] = { let __args: [G; IN_17] = [__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 __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];
@@ -2433,30 +2533,30 @@ fn aiur_fn_16(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_40: G = G::from_u64(0);
-        let __ret: [G; OUT_16] = [__v_40];
-        record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_16] = { let __args: [G; IN_16] = [__v_2]; 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 __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_16] = [__v_40];
-        record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_20] = [__v_40];
+        record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_17: usize = 1;
-const IN_17: usize = 1;
-const OUT_17: usize = 32;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_21: usize = 1;
+const IN_21: usize = 1;
+const OUT_21: usize = 32;
+fn aiur_fn_21(
+  inp: [G; IN_21],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], ExecError> {
+) -> Result<[G; OUT_21], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -2509,7 +2609,7 @@ fn aiur_fn_17(
     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_22] = { let __args: [G; IN_22] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; 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_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 __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];
@@ -2546,7 +2646,7 @@ fn aiur_fn_17(
     let __v_83: G = __loaded[31];
     let __v_84: G = __loaded[32];
     let __v_85: G = __loaded[33];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__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[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_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 __v_86: G = __r_arr[0];
     let __v_87: G = __r_arr[1];
     let __v_88: G = __r_arr[2];
@@ -2579,21 +2679,21 @@ fn aiur_fn_17(
     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_17] = [__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[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_18: usize = 33;
-const IN_18: usize = 33;
-const OUT_18: usize = 0;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_22: usize = 33;
+const IN_22: usize = 33;
+const OUT_22: usize = 0;
+fn aiur_fn_22(
+  inp: [G; IN_22],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], 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];
@@ -2628,7 +2728,7 @@ fn aiur_fn_18(
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0]; 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_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 __v_33: G = __r_arr[0];
     let __v_34: G = __r_arr[1];
     let __v_35: G = __r_arr[2];
@@ -2757,24 +2857,24 @@ fn aiur_fn_18(
     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_18] = [];
-    record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_22] = [];
+    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 1;
-const IN_19: usize = 1;
-const OUT_19: usize = 1;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+const INPUT_SIZE_23: usize = 1;
+const IN_23: usize = 1;
+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_19], ExecError> {
+) -> Result<[G; OUT_23], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0]; 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_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -2808,21 +2908,21 @@ fn aiur_fn_19(
     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_19] = [__v_33];
-    record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_23] = [__v_33];
+    record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_20: usize = 67;
-const IN_20: usize = 67;
-const OUT_20: usize = 67;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_24: usize = 67;
+const IN_24: usize = 67;
+const OUT_24: usize = 67;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], 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];
@@ -2896,8 +2996,8 @@ fn aiur_fn_20(
         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_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -2937,7 +3037,7 @@ fn aiur_fn_20(
         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_20] = { let __args: [G; IN_20] = [__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[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_102: G = __r_arr[0];
         let __v_103: G = __r_arr[1];
         let __v_104: G = __r_arr[2];
@@ -3008,8 +3108,8 @@ fn aiur_fn_20(
         match __v_102.as_canonical_u64() {
           0u64 => {
             let __v_169: G = G::from_u64(1);
-            let __ret: [G; OUT_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           1u64 => {
@@ -3060,7 +3160,7 @@ fn aiur_fn_20(
                 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_29] = { let __args: [G; IN_29] = [__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[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_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 __v_214: G = __r_arr[0];
                 let __v_215: G = __r_arr[1];
                 let __v_216: G = __r_arr[2];
@@ -3097,8 +3197,8 @@ fn aiur_fn_20(
                 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_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -3111,7 +3211,7 @@ fn aiur_fn_20(
                 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_29] = { let __args: [G; IN_29] = [__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[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_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 __v_212: G = __r_arr[0];
                 let __v_213: G = __r_arr[1];
                 let __v_214: G = __r_arr[2];
@@ -3148,8 +3248,8 @@ fn aiur_fn_20(
                 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_20] = [__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[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -3166,15 +3266,15 @@ fn aiur_fn_20(
   })
 }
 
-const INPUT_SIZE_21: usize = 34;
-const IN_21: usize = 34;
-const OUT_21: usize = 32;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_25: usize = 34;
+const IN_25: usize = 34;
+const OUT_25: usize = 32;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_21], 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];
@@ -3249,8 +3349,8 @@ fn aiur_fn_21(
         let __v_67: G = __loaded[33];
         match __v_34.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_21] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __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[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -3290,7 +3390,7 @@ fn aiur_fn_21(
             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_20] = { let __args: [G; IN_20] = [__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[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 __v_103: G = __r_arr[0];
             let __v_104: G = __r_arr[1];
             let __v_105: G = __r_arr[2];
@@ -3360,7 +3460,7 @@ fn aiur_fn_21(
             let __v_169: G = __r_arr[66];
             match __v_103.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__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[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_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 __v_170: G = __r_arr[0];
                 let __v_171: G = __r_arr[1];
                 let __v_172: G = __r_arr[2];
@@ -3393,14 +3493,14 @@ fn aiur_fn_21(
                 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_21] = [__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[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 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_21] = { let __args: [G; IN_21] = [__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[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_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 __v_172: G = __r_arr[0];
                 let __v_173: G = __r_arr[1];
                 let __v_174: G = __r_arr[2];
@@ -3433,8 +3533,8 @@ fn aiur_fn_21(
                 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_21] = [__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[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -3451,15 +3551,15 @@ fn aiur_fn_21(
   })
 }
 
-const INPUT_SIZE_22: usize = 7;
-const IN_22: usize = 7;
-const OUT_22: usize = 1;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_26: usize = 7;
+const IN_26: usize = 7;
+const OUT_26: usize = 1;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], 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];
@@ -3474,10 +3574,10 @@ fn aiur_fn_22(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+        let __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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_22] = [__v_10];
-        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_26] = [__v_10];
+        record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -3485,10 +3585,10 @@ fn aiur_fn_22(
         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_26] = { let __args: [G; IN_26] = [__v_9, __v_11, __v_3, __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_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 __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_22] = [__v_12];
-            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_26] = [__v_12];
+            record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -3496,10 +3596,10 @@ fn aiur_fn_22(
             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_22] = { let __args: [G; IN_22] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_22] = [__v_16];
-            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_26] = [__v_16];
+            record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -3511,15 +3611,15 @@ fn aiur_fn_22(
   })
 }
 
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 64;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_27: usize = 1;
+const IN_27: usize = 1;
+const OUT_27: usize = 64;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_27], 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 };
@@ -3906,8 +4006,8 @@ fn aiur_fn_23(
                                                                                                                                                                                                                                                                 let __v_192: G = __loaded[2];
                                                                                                                                                                                                                                                                 match __v_190.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_23] = [__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[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                    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));
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -4232,22 +4332,22 @@ fn aiur_fn_23(
   })
 }
 
-const INPUT_SIZE_24: usize = 2;
-const IN_24: usize = 2;
-const OUT_24: usize = 1;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_28: usize = 2;
+const IN_28: usize = 2;
+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_24], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_24] = [__v_0];
-        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_28] = [__v_0];
+        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -4256,25 +4356,25 @@ fn aiur_fn_24(
         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_24] = { let __args: [G; IN_24] = [__v_4, __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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_24] = [__v_7];
-        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_28] = [__v_7];
+        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_25: usize = 6;
-const IN_25: usize = 6;
-const OUT_25: usize = 1;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_29: usize = 6;
+const IN_29: usize = 6;
+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_25], 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];
@@ -4424,7 +4524,7 @@ fn aiur_fn_25(
                                             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_29] = { let __args: [G; IN_29] = [__v_20, __v_21, __v_22, __v_23, __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[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_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 __v_125: G = __r_arr[0];
                                             let __v_126: G = __r_arr[1];
                                             let __v_127: G = __r_arr[2];
@@ -4458,62 +4558,62 @@ fn aiur_fn_25(
                                             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_25] = [__v_157];
-                                            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_29] = [__v_157];
+                                            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __ret: [G; OUT_25] = [__v_5];
-                                            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_29] = [__v_5];
+                                            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_25] = [__v_5];
-                                        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_29] = [__v_5];
+                                        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_25] = [__v_5];
-                                    record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_29] = [__v_5];
+                                    record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_25] = [__v_5];
-                                record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_29] = [__v_5];
+                                record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_25] = [__v_5];
-                            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_29] = [__v_5];
+                            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_25] = [__v_5];
-                        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_29] = [__v_5];
+                        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_25] = [__v_5];
-                    record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_29] = [__v_5];
+                    record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_25] = [__v_5];
-                record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_29] = [__v_5];
+                record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -4554,8 +4654,8 @@ fn aiur_fn_25(
             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_25] = [__v_42];
-            record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_29] = [__v_42];
+            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -4580,9 +4680,9 @@ fn aiur_fn_25(
         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_24] = { let __args: [G; IN_24] = [__v_0, __v_25]; 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_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 __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_26]; 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_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 __v_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -4690,7 +4790,7 @@ fn aiur_fn_25(
         let __v_129: G = __loaded[5];
         let __v_130: G = __loaded[6];
         let __v_131: G = __loaded[7];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__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[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_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 __v_132: G = __r_arr[0];
         let __v_133: G = __r_arr[1];
         let __v_134: G = __r_arr[2];
@@ -4724,23 +4824,23 @@ fn aiur_fn_25(
         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_25] = [__v_164];
-        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_164];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_26: usize = 6;
-const IN_26: usize = 6;
-const OUT_26: usize = 1;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_30: usize = 6;
+const IN_30: usize = 6;
+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_26], 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];
@@ -4751,7 +4851,7 @@ fn aiur_fn_26(
     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_23] = { let __args: [G; IN_23] = [__v_1]; 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_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 __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
@@ -4818,7 +4918,7 @@ fn aiur_fn_26(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0]; 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_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 __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];
@@ -4910,7 +5010,7 @@ fn aiur_fn_26(
         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_29] = { let __args: [G; IN_29] = [__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[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_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 __v_160: G = __r_arr[0];
         let __v_161: G = __r_arr[1];
         let __v_162: G = __r_arr[2];
@@ -4958,7 +5058,7 @@ fn aiur_fn_26(
         let __v_203: G = __loaded[5];
         let __v_204: G = __loaded[6];
         let __v_205: G = __loaded[7];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[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_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 __v_206: G = __r_arr[0];
         let __v_207: G = __r_arr[1];
         let __v_208: G = __r_arr[2];
@@ -4969,17 +5069,17 @@ fn aiur_fn_26(
         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_22] = { let __args: [G; IN_22] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; 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_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 __v_216: G = __r_arr[0];
-        let __ret: [G; OUT_26] = [__v_216];
-        record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_30] = [__v_216];
+        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0]; 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_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 __v_73: G = __r_arr[0];
         let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0]; 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_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 __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];
@@ -5043,7 +5143,7 @@ fn aiur_fn_26(
         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_29] = { let __args: [G; IN_29] = [__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[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_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 __v_134: G = __r_arr[0];
         let __v_135: G = __r_arr[1];
         let __v_136: G = __r_arr[2];
@@ -5083,25 +5183,25 @@ fn aiur_fn_26(
         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_22] = { let __args: [G; IN_22] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; 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_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 __v_173: G = __r_arr[0];
-        let __ret: [G; OUT_26] = [__v_173];
-        record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_30] = [__v_173];
+        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_27: usize = 24;
-const IN_27: usize = 24;
-const OUT_27: usize = 16;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_31: usize = 24;
+const IN_31: usize = 24;
+const OUT_31: usize = 16;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], 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];
@@ -5301,21 +5401,21 @@ fn aiur_fn_27(
     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_27] = [__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[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_28: usize = 128;
-const IN_28: usize = 128;
-const OUT_28: usize = 128;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_32: usize = 128;
+const IN_32: usize = 128;
+const OUT_32: usize = 128;
+fn aiur_fn_32(
+  inp: [G; IN_32],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], 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];
@@ -5445,7 +5545,7 @@ fn aiur_fn_28(
     let __v_125: G = inp[125];
     let __v_126: G = inp[126];
     let __v_127: G = inp[127];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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[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_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 __v_128: G = __r_arr[0];
     let __v_129: G = __r_arr[1];
     let __v_130: G = __r_arr[2];
@@ -5462,7 +5562,7 @@ fn aiur_fn_28(
     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_27] = { let __args: [G; IN_27] = [__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[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_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 __v_144: G = __r_arr[0];
     let __v_145: G = __r_arr[1];
     let __v_146: G = __r_arr[2];
@@ -5479,7 +5579,7 @@ fn aiur_fn_28(
     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_27] = { let __args: [G; IN_27] = [__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[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_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 __v_160: G = __r_arr[0];
     let __v_161: G = __r_arr[1];
     let __v_162: G = __r_arr[2];
@@ -5496,7 +5596,7 @@ fn aiur_fn_28(
     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_27] = { let __args: [G; IN_27] = [__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[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_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 __v_176: G = __r_arr[0];
     let __v_177: G = __r_arr[1];
     let __v_178: G = __r_arr[2];
@@ -5513,7 +5613,7 @@ fn aiur_fn_28(
     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_27] = { let __args: [G; IN_27] = [__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[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_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 __v_192: G = __r_arr[0];
     let __v_193: G = __r_arr[1];
     let __v_194: G = __r_arr[2];
@@ -5530,7 +5630,7 @@ fn aiur_fn_28(
     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_27] = { let __args: [G; IN_27] = [__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[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_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 __v_208: G = __r_arr[0];
     let __v_209: G = __r_arr[1];
     let __v_210: G = __r_arr[2];
@@ -5547,7 +5647,7 @@ fn aiur_fn_28(
     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_27] = { let __args: [G; IN_27] = [__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[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_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 __v_224: G = __r_arr[0];
     let __v_225: G = __r_arr[1];
     let __v_226: G = __r_arr[2];
@@ -5564,7 +5664,7 @@ fn aiur_fn_28(
     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_27] = { let __args: [G; IN_27] = [__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[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_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 __v_240: G = __r_arr[0];
     let __v_241: G = __r_arr[1];
     let __v_242: G = __r_arr[2];
@@ -5581,21 +5681,21 @@ fn aiur_fn_28(
     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_28] = [__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[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_29: usize = 106;
-const IN_29: usize = 106;
-const OUT_29: usize = 32;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+const INPUT_SIZE_33: usize = 106;
+const IN_33: usize = 106;
+const OUT_33: usize = 32;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], 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];
@@ -5725,7 +5825,7 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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_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 __v_128: G = __r_arr[0];
     let __v_129: G = __r_arr[1];
     let __v_130: G = __r_arr[2];
@@ -5854,7 +5954,7 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__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[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_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 __v_256: G = __r_arr[0];
     let __v_257: G = __r_arr[1];
     let __v_258: G = __r_arr[2];
@@ -5983,7 +6083,7 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__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[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_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 __v_384: G = __r_arr[0];
     let __v_385: G = __r_arr[1];
     let __v_386: G = __r_arr[2];
@@ -6112,7 +6212,7 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__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[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_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 __v_512: G = __r_arr[0];
     let __v_513: G = __r_arr[1];
     let __v_514: G = __r_arr[2];
@@ -6241,7 +6341,7 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__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[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_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 __v_640: G = __r_arr[0];
     let __v_641: G = __r_arr[1];
     let __v_642: G = __r_arr[2];
@@ -6370,7 +6470,7 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__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[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_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 __v_768: G = __r_arr[0];
     let __v_769: G = __r_arr[1];
     let __v_770: G = __r_arr[2];
@@ -6499,7 +6599,7 @@ fn aiur_fn_29(
     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_28] = { let __args: [G; IN_28] = [__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[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_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 __v_896: G = __r_arr[0];
     let __v_897: G = __r_arr[1];
     let __v_898: G = __r_arr[2];
@@ -6660,27 +6760,27 @@ fn aiur_fn_29(
     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_29] = [__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[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_30: usize = 0;
-const IN_30: usize = 0;
-const OUT_30: usize = 22;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+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_30], ExecError> {
+) -> 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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6688,13 +6788,13 @@ fn aiur_fn_30(
     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_780] = { let __args: [G; IN_780] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6703,7 +6803,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6712,7 +6812,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6720,19 +6820,19 @@ fn aiur_fn_30(
     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_780] = { let __args: [G; IN_780] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_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_780] = { let __args: [G; IN_780] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_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_780] = { let __args: [G; IN_780] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6741,7 +6841,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6749,13 +6849,13 @@ fn aiur_fn_30(
     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_780] = { let __args: [G; IN_780] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; 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_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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6764,7 +6864,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6773,7 +6873,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6782,7 +6882,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6791,7 +6891,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6799,25 +6899,25 @@ fn aiur_fn_30(
     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_780] = { let __args: [G; IN_780] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_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_780] = { let __args: [G; IN_780] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_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_780] = { let __args: [G; IN_780] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_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_780] = { let __args: [G; IN_780] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_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_780] = { let __args: [G; IN_780] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6826,7 +6926,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6835,7 +6935,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6844,7 +6944,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6853,7 +6953,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6861,25 +6961,25 @@ fn aiur_fn_30(
     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_780] = { let __args: [G; IN_780] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_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_780] = { let __args: [G; IN_780] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_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_780] = { let __args: [G; IN_780] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_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_780] = { let __args: [G; IN_780] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_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_780] = { let __args: [G; IN_780] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6888,7 +6988,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6897,7 +6997,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6906,7 +7006,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6915,7 +7015,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6924,7 +7024,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6933,7 +7033,7 @@ fn aiur_fn_30(
     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_784] = { let __args: [G; IN_784] = [__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[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_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];
@@ -6941,41 +7041,41 @@ fn aiur_fn_30(
     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_780] = { let __args: [G; IN_780] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_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_780] = { let __args: [G; IN_780] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_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_780] = { let __args: [G; IN_780] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_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_780] = { let __args: [G; IN_780] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_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_780] = { let __args: [G; IN_780] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_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_780] = { let __args: [G; IN_780] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_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_780] = { let __args: [G; IN_780] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_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_30] = [__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[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_31: usize = 19;
-const IN_31: usize = 19;
-const OUT_31: usize = 1;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+const INPUT_SIZE_35: usize = 19;
+const IN_35: usize = 19;
+const OUT_35: usize = 1;
+fn aiur_fn_35(
+  inp: [G; IN_35],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_31], 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];
@@ -6999,22 +7099,22 @@ fn aiur_fn_31(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_20];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_19: G = G::from_u64(1);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_20];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7024,18 +7124,18 @@ fn aiur_fn_31(
         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_36] = { let __args: [G; IN_36] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __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 __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_30];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_30];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7045,14 +7145,14 @@ fn aiur_fn_31(
         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_36] = { let __args: [G; IN_36] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __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 __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_30];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_30];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
@@ -7076,34 +7176,34 @@ fn aiur_fn_31(
         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_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; 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_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 __v_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_40: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_40];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_40];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_19: G = G::from_u64(5);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_20];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_19: G = G::from_u64(6);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_20];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7113,16 +7213,16 @@ fn aiur_fn_31(
         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_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } else { aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_29];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_29];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        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]; 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_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7132,16 +7232,16 @@ fn aiur_fn_31(
         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_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, __v_18]; 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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_29];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_29];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7151,12 +7251,12 @@ fn aiur_fn_31(
         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_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, __v_18]; 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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_29];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_29];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
@@ -7218,24 +7318,24 @@ fn aiur_fn_31(
         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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_74: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[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_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 __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_77: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_77];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_77];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
         let __v_19: G = G::from_u64(11);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_31] = [__v_20];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_20];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7245,15 +7345,15 @@ fn aiur_fn_31(
   })
 }
 
-const INPUT_SIZE_32: usize = 10;
-const IN_32: usize = 10;
-const OUT_32: usize = 1;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+const INPUT_SIZE_36: usize = 10;
+const IN_36: usize = 10;
+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_32], 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];
@@ -7267,8 +7367,8 @@ fn aiur_fn_32(
     let __v_9: G = inp[9];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_32] = [__v_9];
-        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_36] = [__v_9];
+        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7276,26 +7376,26 @@ fn aiur_fn_32(
         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_32] = { let __args: [G; IN_32] = [__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[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_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 __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_32] = [__v_15];
-        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_36] = [__v_15];
+        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_33: usize = 9;
-const IN_33: usize = 9;
-const OUT_33: usize = 1;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+const INPUT_SIZE_37: usize = 9;
+const IN_37: usize = 9;
+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_33], 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];
@@ -7316,8 +7416,8 @@ fn aiur_fn_33(
           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_33] = [__v_13];
-            record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_37] = [__v_13];
+            record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7326,11 +7426,11 @@ fn aiur_fn_33(
             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_32] = { let __args: [G; IN_32] = [__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[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_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 __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_33] = [__v_18];
-            record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_37] = [__v_18];
+            record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7341,26 +7441,26 @@ fn aiur_fn_33(
         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_32] = { let __args: [G; IN_32] = [__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[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_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 __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_33] = [__v_18];
-        record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_37] = [__v_18];
+        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_34: usize = 10;
-const IN_34: usize = 10;
-const OUT_34: usize = 1;
-fn aiur_fn_34(
-  inp: [G; IN_34],
+const INPUT_SIZE_38: usize = 10;
+const IN_38: usize = 10;
+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_34], 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];
@@ -7385,8 +7485,8 @@ fn aiur_fn_34(
             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_34] = [__v_17];
-            record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_38] = [__v_17];
+            record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7398,11 +7498,11 @@ fn aiur_fn_34(
             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_32] = { let __args: [G; IN_32] = [__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[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_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 __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_34] = [__v_22];
-            record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_38] = [__v_22];
+            record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7416,26 +7516,26 @@ fn aiur_fn_34(
         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_32] = { let __args: [G; IN_32] = [__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[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_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 __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_34] = [__v_22];
-        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_38] = [__v_22];
+        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_35: usize = 10;
-const IN_35: usize = 10;
-const OUT_35: usize = 1;
-fn aiur_fn_35(
-  inp: [G; IN_35],
+const INPUT_SIZE_39: usize = 10;
+const IN_39: usize = 10;
+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_35], 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];
@@ -7460,8 +7560,8 @@ fn aiur_fn_35(
             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_35] = [__v_17];
-            record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_39] = [__v_17];
+            record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7473,11 +7573,11 @@ fn aiur_fn_35(
             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_32] = { let __args: [G; IN_32] = [__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[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_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 __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_35] = [__v_22];
-            record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_39] = [__v_22];
+            record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -7491,26 +7591,26 @@ fn aiur_fn_35(
         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_32] = { let __args: [G; IN_32] = [__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[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_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 __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_35] = [__v_22];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_39] = [__v_22];
+        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_36: usize = 2;
-const IN_36: usize = 2;
-const OUT_36: usize = 1;
-fn aiur_fn_36(
-  inp: [G; IN_36],
+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_36], 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];
@@ -7527,17 +7627,17 @@ fn aiur_fn_36(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_36] = [__v_1];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_40] = [__v_1];
+        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_11, __v_1]; 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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !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_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 __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_36] = [__v_13];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_40] = [__v_13];
+        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7547,15 +7647,15 @@ fn aiur_fn_36(
   })
 }
 
-const INPUT_SIZE_37: usize = 18;
-const IN_37: usize = 18;
-const OUT_37: usize = 8;
-fn aiur_fn_37(
-  inp: [G; IN_37],
+const INPUT_SIZE_41: usize = 18;
+const IN_41: usize = 18;
+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_37], 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];
@@ -7596,7 +7696,7 @@ fn aiur_fn_37(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __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 __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7605,7 +7705,7 @@ fn aiur_fn_37(
         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_10] = { let __args: [G; IN_10] = [__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[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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7614,8 +7714,8 @@ fn aiur_fn_37(
         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_37] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -7627,23 +7727,23 @@ fn aiur_fn_37(
         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_37] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 18;
-const IN_38: usize = 18;
-const OUT_38: usize = 8;
-fn aiur_fn_38(
-  inp: [G; IN_38],
+const INPUT_SIZE_42: usize = 18;
+const IN_42: usize = 18;
+const OUT_42: usize = 8;
+fn aiur_fn_42(
+  inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_38], 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];
@@ -7684,7 +7784,7 @@ fn aiur_fn_38(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7693,7 +7793,7 @@ fn aiur_fn_38(
         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_10] = { let __args: [G; IN_10] = [__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[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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7702,8 +7802,8 @@ fn aiur_fn_38(
         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_38] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -7715,23 +7815,23 @@ fn aiur_fn_38(
         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_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[38].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];
+        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_39: usize = 18;
-const IN_39: usize = 18;
-const OUT_39: usize = 8;
-fn aiur_fn_39(
-  inp: [G; IN_39],
+const INPUT_SIZE_43: usize = 18;
+const IN_43: usize = 18;
+const OUT_43: usize = 8;
+fn aiur_fn_43(
+  inp: [G; IN_43],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_39], 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];
@@ -7772,7 +7872,7 @@ fn aiur_fn_39(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7781,7 +7881,7 @@ fn aiur_fn_39(
         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_10] = { let __args: [G; IN_10] = [__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[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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7790,8 +7890,8 @@ fn aiur_fn_39(
         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_39] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -7803,23 +7903,23 @@ fn aiur_fn_39(
         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_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_40: usize = 19;
-const IN_40: usize = 19;
-const OUT_40: usize = 1;
-fn aiur_fn_40(
-  inp: [G; IN_40],
+const INPUT_SIZE_44: usize = 19;
+const IN_44: usize = 19;
+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_40], 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];
@@ -7880,210 +7980,210 @@ fn aiur_fn_40(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[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_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 __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 __v_56: G = __r_arr[0];
+        let __ret: [G; OUT_44] = [__v_56];
+        record.function_queries[44].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 __v_19: G = __r_arr[0];
+        let __ret: [G; OUT_44] = [__v_19];
+        record.function_queries[44].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],
+  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];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    match __v_0.as_canonical_u64() {
+      8u64 => {
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __v_19: G = __loaded[0];
+        let __v_20: G = __loaded[1];
+        let __v_21: G = __loaded[2];
+        let __v_22: G = __loaded[3];
+        let __v_23: G = __loaded[4];
+        let __v_24: G = __loaded[5];
+        let __v_25: G = __loaded[6];
+        let __v_26: G = __loaded[7];
+        let __v_27: G = __loaded[8];
+        let __v_28: G = __loaded[9];
+        let __v_29: G = __loaded[10];
+        let __v_30: G = __loaded[11];
+        let __v_31: G = __loaded[12];
+        let __v_32: G = __loaded[13];
+        let __v_33: G = __loaded[14];
+        let __v_34: G = __loaded[15];
+        let __v_35: G = __loaded[16];
+        let __v_36: G = __loaded[17];
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __v_37: G = __loaded[0];
+        let __v_38: G = __loaded[1];
+        let __v_39: G = __loaded[2];
+        let __v_40: G = __loaded[3];
+        let __v_41: G = __loaded[4];
+        let __v_42: G = __loaded[5];
+        let __v_43: G = __loaded[6];
+        let __v_44: G = __loaded[7];
+        let __v_45: G = __loaded[8];
+        let __v_46: G = __loaded[9];
+        let __v_47: G = __loaded[10];
+        let __v_48: G = __loaded[11];
+        let __v_49: G = __loaded[12];
+        let __v_50: G = __loaded[13];
+        let __v_51: G = __loaded[14];
+        let __v_52: G = __loaded[15];
+        let __v_53: G = __loaded[16];
+        let __v_54: G = __loaded[17];
+        let __r_arr: [G; OUT_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 __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 __v_56: G = __r_arr[0];
+        let __ret: [G; OUT_45] = [__v_56];
+        record.function_queries[45].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 __v_19: G = __r_arr[0];
+        let __ret: [G; OUT_45] = [__v_19];
+        record.function_queries[45].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],
+  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 __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    match __v_0.as_canonical_u64() {
+      9u64 => {
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __v_19: G = __loaded[0];
+        let __v_20: G = __loaded[1];
+        let __v_21: G = __loaded[2];
+        let __v_22: G = __loaded[3];
+        let __v_23: G = __loaded[4];
+        let __v_24: G = __loaded[5];
+        let __v_25: G = __loaded[6];
+        let __v_26: G = __loaded[7];
+        let __v_27: G = __loaded[8];
+        let __v_28: G = __loaded[9];
+        let __v_29: G = __loaded[10];
+        let __v_30: G = __loaded[11];
+        let __v_31: G = __loaded[12];
+        let __v_32: G = __loaded[13];
+        let __v_33: G = __loaded[14];
+        let __v_34: G = __loaded[15];
+        let __v_35: G = __loaded[16];
+        let __v_36: G = __loaded[17];
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __v_37: G = __loaded[0];
+        let __v_38: G = __loaded[1];
+        let __v_39: G = __loaded[2];
+        let __v_40: G = __loaded[3];
+        let __v_41: G = __loaded[4];
+        let __v_42: G = __loaded[5];
+        let __v_43: G = __loaded[6];
+        let __v_44: G = __loaded[7];
+        let __v_45: G = __loaded[8];
+        let __v_46: G = __loaded[9];
+        let __v_47: G = __loaded[10];
+        let __v_48: G = __loaded[11];
+        let __v_49: G = __loaded[12];
+        let __v_50: G = __loaded[13];
+        let __v_51: G = __loaded[14];
+        let __v_52: G = __loaded[15];
+        let __v_53: G = __loaded[16];
+        let __v_54: G = __loaded[17];
+        let __r_arr: [G; OUT_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_40] = [__v_56];
-        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_40] = [__v_19];
-        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_41: usize = 19;
-const IN_41: usize = 19;
-const OUT_41: usize = 1;
-fn aiur_fn_41(
-  inp: [G; IN_41],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_41], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    match __v_0.as_canonical_u64() {
-      8u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_19: G = __loaded[0];
-        let __v_20: G = __loaded[1];
-        let __v_21: G = __loaded[2];
-        let __v_22: G = __loaded[3];
-        let __v_23: G = __loaded[4];
-        let __v_24: G = __loaded[5];
-        let __v_25: G = __loaded[6];
-        let __v_26: G = __loaded[7];
-        let __v_27: G = __loaded[8];
-        let __v_28: G = __loaded[9];
-        let __v_29: G = __loaded[10];
-        let __v_30: G = __loaded[11];
-        let __v_31: G = __loaded[12];
-        let __v_32: G = __loaded[13];
-        let __v_33: G = __loaded[14];
-        let __v_34: G = __loaded[15];
-        let __v_35: G = __loaded[16];
-        let __v_36: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_37: G = __loaded[0];
-        let __v_38: G = __loaded[1];
-        let __v_39: G = __loaded[2];
-        let __v_40: G = __loaded[3];
-        let __v_41: G = __loaded[4];
-        let __v_42: G = __loaded[5];
-        let __v_43: G = __loaded[6];
-        let __v_44: G = __loaded[7];
-        let __v_45: G = __loaded[8];
-        let __v_46: G = __loaded[9];
-        let __v_47: G = __loaded[10];
-        let __v_48: G = __loaded[11];
-        let __v_49: G = __loaded[12];
-        let __v_50: G = __loaded[13];
-        let __v_51: G = __loaded[14];
-        let __v_52: G = __loaded[15];
-        let __v_53: G = __loaded[16];
-        let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__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[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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_41] = [__v_56];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_41] = [__v_19];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_42: usize = 19;
-const IN_42: usize = 19;
-const OUT_42: usize = 1;
-fn aiur_fn_42(
-  inp: [G; IN_42],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_42], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    match __v_0.as_canonical_u64() {
-      9u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_19: G = __loaded[0];
-        let __v_20: G = __loaded[1];
-        let __v_21: G = __loaded[2];
-        let __v_22: G = __loaded[3];
-        let __v_23: G = __loaded[4];
-        let __v_24: G = __loaded[5];
-        let __v_25: G = __loaded[6];
-        let __v_26: G = __loaded[7];
-        let __v_27: G = __loaded[8];
-        let __v_28: G = __loaded[9];
-        let __v_29: G = __loaded[10];
-        let __v_30: G = __loaded[11];
-        let __v_31: G = __loaded[12];
-        let __v_32: G = __loaded[13];
-        let __v_33: G = __loaded[14];
-        let __v_34: G = __loaded[15];
-        let __v_35: G = __loaded[16];
-        let __v_36: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_37: G = __loaded[0];
-        let __v_38: G = __loaded[1];
-        let __v_39: G = __loaded[2];
-        let __v_40: G = __loaded[3];
-        let __v_41: G = __loaded[4];
-        let __v_42: G = __loaded[5];
-        let __v_43: G = __loaded[6];
-        let __v_44: G = __loaded[7];
-        let __v_45: G = __loaded[8];
-        let __v_46: G = __loaded[9];
-        let __v_47: G = __loaded[10];
-        let __v_48: G = __loaded[11];
-        let __v_49: G = __loaded[12];
-        let __v_50: G = __loaded[13];
-        let __v_51: G = __loaded[14];
-        let __v_52: G = __loaded[15];
-        let __v_53: G = __loaded[16];
-        let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__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[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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_20, __v_21, __v_22, __v_23, __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[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_42] = [__v_56];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_46] = [__v_56];
+        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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[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_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 __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_42] = [__v_19];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_46] = [__v_19];
+        record.function_queries[46].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 = 1;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+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_43], 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];
@@ -8184,21 +8284,21 @@ fn aiur_fn_43(
     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_43] = [__v_97];
-    record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_47] = [__v_97];
+    record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_44: usize = 2;
-const IN_44: usize = 2;
-const OUT_44: usize = 1;
-fn aiur_fn_44(
-  inp: [G; IN_44],
+const INPUT_SIZE_48: usize = 2;
+const IN_48: usize = 2;
+const OUT_48: usize = 1;
+fn aiur_fn_48(
+  inp: [G; IN_48],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_44], 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];
@@ -8207,20 +8307,20 @@ fn aiur_fn_44(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(2);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8232,20 +8332,20 @@ fn aiur_fn_44(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(4);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(5);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(6);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8257,20 +8357,20 @@ fn aiur_fn_44(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(8);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(9);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(10);
-            let __ret: [G; OUT_44] = [__v_2];
-            record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_48] = [__v_2];
+            record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -8285,15 +8385,15 @@ fn aiur_fn_44(
   })
 }
 
-const INPUT_SIZE_45: usize = 9;
-const IN_45: usize = 9;
-const OUT_45: usize = 8;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_49: usize = 9;
+const IN_49: usize = 9;
+const OUT_49: usize = 8;
+fn aiur_fn_49(
+  inp: [G; IN_49],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_45], 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];
@@ -8316,7 +8416,7 @@ fn aiur_fn_45(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__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[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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8325,7 +8425,7 @@ fn aiur_fn_45(
         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_10] = { let __args: [G; IN_10] = [__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[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_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 __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -8334,8 +8434,8 @@ fn aiur_fn_45(
         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_45] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -8347,23 +8447,23 @@ fn aiur_fn_45(
         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_45] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_46: usize = 9;
-const IN_46: usize = 9;
-const OUT_46: usize = 9;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+const INPUT_SIZE_50: usize = 9;
+const IN_50: usize = 9;
+const OUT_50: usize = 9;
+fn aiur_fn_50(
+  inp: [G; IN_50],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_46], 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];
@@ -8386,7 +8486,7 @@ fn aiur_fn_46(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__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[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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8396,28 +8496,28 @@ fn aiur_fn_46(
         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_46] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_47: usize = 10;
-const IN_47: usize = 10;
-const OUT_47: usize = 1;
-fn aiur_fn_47(
-  inp: [G; IN_47],
+const INPUT_SIZE_51: usize = 10;
+const IN_51: usize = 10;
+const OUT_51: usize = 1;
+fn aiur_fn_51(
+  inp: [G; IN_51],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_47], 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];
@@ -8434,12 +8534,12 @@ fn aiur_fn_47(
         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_47] = [__v_12];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_12];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -8448,7 +8548,7 @@ fn aiur_fn_47(
         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_46] = { let __args: [G; IN_46] = [__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[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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -8459,12 +8559,12 @@ fn aiur_fn_47(
         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_47] = { let __args: [G; IN_47] = [__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[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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_29];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_29];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -8497,14 +8597,14 @@ fn aiur_fn_47(
         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_47] = { let __args: [G; IN_47] = [__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[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_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 __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__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[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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_39];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_39];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
@@ -8537,22 +8637,22 @@ fn aiur_fn_47(
         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_47] = { let __args: [G; IN_47] = [__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[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_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 __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__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[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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_39];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_39];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_11];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_11];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8562,15 +8662,15 @@ fn aiur_fn_47(
   })
 }
 
-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_52: usize = 2;
+const IN_52: usize = 2;
+const OUT_52: usize = 1;
+fn aiur_fn_52(
+  inp: [G; IN_52],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_48], 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];
@@ -8580,8 +8680,8 @@ fn aiur_fn_48(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_48] = [__v_1];
-        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_52] = [__v_1];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8604,12 +8704,12 @@ fn aiur_fn_48(
         let __v_20: G = __loaded[15];
         let __v_21: G = __loaded[16];
         let __v_22: G = __loaded[17];
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
+        let __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 __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __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[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_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 __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_48] = [__v_24];
-        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_52] = [__v_24];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8619,15 +8719,15 @@ fn aiur_fn_48(
   })
 }
 
-const INPUT_SIZE_49: usize = 2;
-const IN_49: usize = 2;
-const OUT_49: usize = 1;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+const INPUT_SIZE_53: usize = 2;
+const IN_53: usize = 2;
+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_49], 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];
@@ -8637,8 +8737,8 @@ fn aiur_fn_49(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_49] = [__v_1];
-        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_53] = [__v_1];
+        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8652,12 +8752,12 @@ fn aiur_fn_49(
         let __v_11: G = __loaded[6];
         let __v_12: G = __loaded[7];
         let __v_13: G = __loaded[8];
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_4, __v_1]; 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_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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__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[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_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 __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_49] = [__v_15];
-        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_53] = [__v_15];
+        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8667,15 +8767,15 @@ fn aiur_fn_49(
   })
 }
 
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
-const OUT_50: usize = 1;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_54: usize = 2;
+const IN_54: usize = 2;
+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_50], 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];
@@ -8685,17 +8785,17 @@ fn aiur_fn_50(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_50] = [__v_1];
-        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_1];
+        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_5: G = __r_arr[0];
-        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 __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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_50] = [__v_6];
-        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_6];
+        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8705,15 +8805,15 @@ fn aiur_fn_50(
   })
 }
 
-const INPUT_SIZE_51: usize = 2;
-const IN_51: usize = 2;
-const OUT_51: usize = 1;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+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_51], 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];
@@ -8722,32 +8822,32 @@ fn aiur_fn_51(
         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_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_4];
+        record.function_queries[55].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_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_4];
+        record.function_queries[55].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_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_4];
+        record.function_queries[55].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_51] = [__v_4];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_4];
+        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8757,15 +8857,15 @@ fn aiur_fn_51(
   })
 }
 
-const INPUT_SIZE_52: usize = 13;
-const IN_52: usize = 13;
-const OUT_52: usize = 1;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_56: usize = 13;
+const IN_56: usize = 13;
+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_52], 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];
@@ -8820,33 +8920,33 @@ fn aiur_fn_52(
         let __v_46: G = __loaded[15];
         let __v_47: G = __loaded[16];
         let __v_48: G = __loaded[17];
-        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
         let __v_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(0);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[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_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 __v_51: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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[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_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 __v_52: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __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_52] = [__v_54];
-        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_56] = [__v_54];
+        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_53: usize = 10;
-const IN_53: usize = 10;
-const OUT_53: usize = 1;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+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_53], 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];
@@ -8879,27 +8979,27 @@ fn aiur_fn_53(
         let __v_25: G = __loaded[15];
         let __v_26: G = __loaded[16];
         let __v_27: G = __loaded[17];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_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[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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __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 __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_53] = [__v_29];
-        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_57] = [__v_29];
+        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_58: usize = 2;
+const IN_58: usize = 2;
+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_54], 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];
@@ -8917,17 +9017,17 @@ fn aiur_fn_54(
     let __v_12: G = __loaded[10];
     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_58] = [__v_1];
+        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_12, __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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__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[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_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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_54] = [__v_14];
-        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_58] = [__v_14];
+        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8937,15 +9037,15 @@ fn aiur_fn_54(
   })
 }
 
-const INPUT_SIZE_55: usize = 45;
-const IN_55: usize = 45;
-const OUT_55: usize = 1;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_59: usize = 45;
+const IN_59: usize = 45;
+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_55], 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];
@@ -9016,7 +9116,7 @@ fn aiur_fn_55(
         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_785] = { let __args: [G; IN_785] = [__v_43]; 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_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 __v_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -9026,40 +9126,40 @@ fn aiur_fn_55(
         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_54] = { let __args: [G; IN_54] = [__v_43, __v_44]; 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_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 __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[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_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 __v_77: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_79: G = __r_arr[0];
-        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_79]; 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_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 __v_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_81: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __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_55] = [__v_83];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_59] = [__v_83];
+        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_56: usize = 11;
-const IN_56: usize = 11;
-const OUT_56: usize = 1;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_60: usize = 11;
+const IN_60: usize = 11;
+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_56], 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];
@@ -9094,28 +9194,28 @@ fn aiur_fn_56(
         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_31] = { let __args: [G; IN_31] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[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_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 __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; 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_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 __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_56] = [__v_32];
-        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_60] = [__v_32];
+        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_57: usize = 11;
-const IN_57: usize = 11;
-const OUT_57: usize = 1;
-fn aiur_fn_57(
-  inp: [G; IN_57],
+const INPUT_SIZE_61: usize = 11;
+const IN_61: usize = 11;
+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_57], 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];
@@ -9149,29 +9249,29 @@ fn aiur_fn_57(
         let __v_26: G = __loaded[15];
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[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_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 __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __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 __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_30]; 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_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 __v_31: G = __r_arr[0];
-        let __ret: [G; OUT_57] = [__v_31];
-        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_31];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_58: usize = 35;
-const IN_58: usize = 35;
-const OUT_58: usize = 1;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_62: usize = 35;
+const IN_62: usize = 35;
+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_58], 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];
@@ -9230,34 +9330,34 @@ fn aiur_fn_58(
         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_31] = { let __args: [G; IN_31] = [__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[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_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 __v_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; 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_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 __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_58] = [__v_59];
-        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_62] = [__v_59];
+        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_59: usize = 2;
-const IN_59: usize = 2;
-const OUT_59: usize = 1;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+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_59], 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];
@@ -9300,17 +9400,17 @@ fn aiur_fn_59(
     let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_59] = [__v_1];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_1];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_37, __v_1]; 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_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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_59] = [__v_39];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_39];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9320,15 +9420,15 @@ fn aiur_fn_59(
   })
 }
 
-const INPUT_SIZE_60: usize = 28;
-const IN_60: usize = 28;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_64: usize = 28;
+const IN_64: usize = 28;
+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_60], 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];
@@ -9379,7 +9479,7 @@ fn aiur_fn_60(
         let __v_43: G = __loaded[15];
         let __v_44: G = __loaded[16];
         let __v_45: G = __loaded[17];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_26]; 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_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 __v_46: G = __r_arr[0];
         let __v_47: G = __r_arr[1];
         let __v_48: G = __r_arr[2];
@@ -9389,36 +9489,36 @@ fn aiur_fn_60(
         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_59] = { let __args: [G; IN_59] = [__v_26, __v_27]; 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_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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[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_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 __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_59: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; 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_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 __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_60] = [__v_61];
-        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_64] = [__v_61];
+        record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_61: usize = 10;
-const IN_61: usize = 10;
-const OUT_61: usize = 1;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_65: usize = 10;
+const IN_65: usize = 10;
+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_61], 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];
@@ -9432,27 +9532,27 @@ fn aiur_fn_61(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; 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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_11];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_65] = [__v_11];
+        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_62: usize = 18;
-const IN_62: usize = 18;
-const OUT_62: usize = 1;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_66: usize = 18;
+const IN_66: usize = 18;
+const OUT_66: usize = 1;
+fn aiur_fn_66(
+  inp: [G; IN_66],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_62], ExecError> {
+) -> Result<[G; OUT_66], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9474,29 +9574,29 @@ fn aiur_fn_62(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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_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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; 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_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 __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_62] = [__v_20];
-        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_66] = [__v_20];
+        record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_63: usize = 46;
-const IN_63: usize = 46;
-const OUT_63: usize = 1;
-fn aiur_fn_63(
-  inp: [G; IN_63],
+const INPUT_SIZE_67: usize = 46;
+const IN_67: usize = 46;
+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_63], 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];
@@ -9548,31 +9648,31 @@ fn aiur_fn_63(
       0u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        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_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __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_63] = [__v_49];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_67] = [__v_49];
+        record.function_queries[67].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_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_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[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_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 __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_63] = [__v_49];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_67] = [__v_49];
+        record.function_queries[67].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_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __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_63] = [__v_49];
-        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_67] = [__v_49];
+        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9582,15 +9682,15 @@ fn aiur_fn_63(
   })
 }
 
-const INPUT_SIZE_64: usize = 2;
-const IN_64: usize = 2;
-const OUT_64: usize = 1;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_68: usize = 2;
+const IN_68: usize = 2;
+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_64], ExecError> {
+) -> 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];
@@ -9644,17 +9744,17 @@ fn aiur_fn_64(
     let __v_48: G = __loaded[46];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_64] = [__v_1];
-        record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_1];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_48, __v_1]; 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_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 __v_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_50: G = __r_arr[0];
-        let __ret: [G; OUT_64] = [__v_50];
-        record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_50];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9664,15 +9764,15 @@ fn aiur_fn_64(
   })
 }
 
-const INPUT_SIZE_65: usize = 46;
-const IN_65: usize = 46;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_69: usize = 46;
+const IN_69: usize = 46;
+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_65], ExecError> {
+) -> Result<[G; OUT_69], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9722,59 +9822,59 @@ fn aiur_fn_65(
     let __v_45: G = inp[45];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        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_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        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_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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        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_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_62] = { let __args: [G; IN_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_45]; 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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        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_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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        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_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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        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_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_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 __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_46];
-        record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_46];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9784,19 +9884,19 @@ fn aiur_fn_65(
   })
 }
 
-const INPUT_SIZE_66: usize = 2;
-const IN_66: usize = 2;
-const OUT_66: usize = 1;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_70: usize = 2;
+const IN_70: usize = 2;
+const OUT_70: usize = 1;
+fn aiur_fn_70(
+  inp: [G; IN_70],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_66], ExecError> {
+) -> 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 __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9805,29 +9905,29 @@ fn aiur_fn_66(
     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_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_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 __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_66] = [__v_11];
-    record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_70] = [__v_11];
+    record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_67: usize = 2;
-const IN_67: usize = 2;
-const OUT_67: usize = 1;
-fn aiur_fn_67(
-  inp: [G; IN_67],
+const INPUT_SIZE_71: usize = 2;
+const IN_71: usize = 2;
+const OUT_71: usize = 1;
+fn aiur_fn_71(
+  inp: [G; IN_71],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_67], 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];
-    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9836,29 +9936,29 @@ fn aiur_fn_67(
     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_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_67] = [__v_11];
-    record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_71] = [__v_11];
+    record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_72: usize = 2;
+const IN_72: usize = 2;
+const OUT_72: usize = 1;
+fn aiur_fn_72(
+  inp: [G; IN_72],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_68], 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];
-    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -9867,25 +9967,25 @@ fn aiur_fn_68(
     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_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; 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_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 __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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[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_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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_68] = [__v_11];
-    record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_72] = [__v_11];
+    record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_69: usize = 49;
-const IN_69: usize = 49;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_69],
+const INPUT_SIZE_73: usize = 49;
+const IN_73: usize = 49;
+const OUT_73: usize = 1;
+fn aiur_fn_73(
+  inp: [G; IN_73],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_69], 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];
@@ -9938,15 +10038,15 @@ fn aiur_fn_69(
     let __v_48: G = inp[48];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_47, __v_48]; 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_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 __v_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_46, __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_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 __v_50: G = __r_arr[0];
-        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_45, __v_50]; 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_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 __v_51: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
+            let __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 __v_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -9956,12 +10056,12 @@ fn aiur_fn_69(
             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_64] = { let __args: [G; IN_64] = [__v_1, __v_51]; 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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -9974,12 +10074,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -9992,12 +10092,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
@@ -10010,12 +10110,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
@@ -10028,12 +10128,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
@@ -10046,12 +10146,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
@@ -10064,12 +10164,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
@@ -10082,12 +10182,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
@@ -10100,12 +10200,12 @@ fn aiur_fn_69(
             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_65] = { let __args: [G; IN_65] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[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_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 __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_69] = [__v_62];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_73] = [__v_62];
+            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -10117,15 +10217,15 @@ fn aiur_fn_69(
   })
 }
 
-const INPUT_SIZE_70: usize = 1;
-const IN_70: usize = 1;
-const OUT_70: usize = 2;
-fn aiur_fn_70(
-  inp: [G; IN_70],
+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_70], ExecError> {
+) -> Result<[G; OUT_74], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -10134,8 +10234,8 @@ fn aiur_fn_70(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_70] = [__v_2, __v_3];
-        record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_2, __v_3];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -10143,8 +10243,8 @@ fn aiur_fn_70(
         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_70] = [__v_4, __v_7];
-        record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_4, __v_7];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10154,15 +10254,15 @@ fn aiur_fn_70(
   })
 }
 
-const INPUT_SIZE_71: usize = 2;
-const IN_71: usize = 2;
-const OUT_71: usize = 9;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_75: usize = 2;
+const IN_75: usize = 2;
+const OUT_75: usize = 9;
+fn aiur_fn_75(
+  inp: [G; IN_75],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_71], ExecError> {
+) -> Result<[G; OUT_75], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10176,8 +10276,8 @@ fn aiur_fn_71(
         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_71] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
-        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -10189,7 +10289,7 @@ fn aiur_fn_71(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_4, __v_6]; 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_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 __v_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             let __v_9: G = __r_arr[2];
@@ -10199,8 +10299,8 @@ fn aiur_fn_71(
             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_71] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
-            record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -10212,15 +10312,15 @@ fn aiur_fn_71(
   })
 }
 
-const INPUT_SIZE_72: usize = 1;
-const IN_72: usize = 1;
-const OUT_72: usize = 9;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+const INPUT_SIZE_76: usize = 1;
+const IN_76: usize = 1;
+const OUT_76: usize = 9;
+fn aiur_fn_76(
+  inp: [G; IN_76],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_72], ExecError> {
+) -> Result<[G; OUT_76], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -10265,14 +10365,14 @@ fn aiur_fn_72(
             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_72] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
-            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
             let __v_30: G = G::from_u64(1);
             let __v_31: G = (__v_29 + __v_30);
-            let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_31]; 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_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 __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
             let __v_34: G = __r_arr[2];
@@ -10282,8 +10382,8 @@ fn aiur_fn_72(
             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_72] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
-            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -10295,15 +10395,15 @@ fn aiur_fn_72(
   })
 }
 
-const INPUT_SIZE_73: usize = 1;
-const IN_73: usize = 1;
-const OUT_73: usize = 10;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+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_73], ExecError> {
+) -> Result<[G; OUT_77], 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 };
@@ -10345,14 +10445,14 @@ fn aiur_fn_73(
             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_73] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_28]; 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_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 __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -10362,8 +10462,8 @@ fn aiur_fn_73(
             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_73] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -10375,15 +10475,15 @@ fn aiur_fn_73(
   })
 }
 
-const INPUT_SIZE_74: usize = 1;
-const IN_74: usize = 1;
-const OUT_74: usize = 10;
-fn aiur_fn_74(
-  inp: [G; IN_74],
+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_74], ExecError> {
+) -> Result<[G; OUT_78], 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 };
@@ -10425,14 +10525,14 @@ fn aiur_fn_74(
             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_74] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_28]; 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_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 __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -10442,8 +10542,8 @@ fn aiur_fn_74(
             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_74] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -10455,15 +10555,15 @@ fn aiur_fn_74(
   })
 }
 
-const INPUT_SIZE_75: usize = 9;
-const IN_75: usize = 9;
-const OUT_75: usize = 2;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_79: usize = 9;
+const IN_79: usize = 9;
+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_75], ExecError> {
+) -> Result<[G; OUT_79], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10481,12 +10581,12 @@ fn aiur_fn_75(
         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_75] = [__v_12, __v_0];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_79] = [__v_12, __v_0];
+        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -10496,7 +10596,7 @@ fn aiur_fn_75(
         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_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 __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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -10505,13 +10605,13 @@ fn aiur_fn_75(
         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_75] = { let __args: [G; IN_75] = [__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[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_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 __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_75] = [__v_30, __v_28];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_79] = [__v_30, __v_28];
+        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10521,15 +10621,15 @@ fn aiur_fn_75(
   })
 }
 
-const INPUT_SIZE_76: usize = 10;
-const IN_76: usize = 10;
-const OUT_76: usize = 2;
-fn aiur_fn_76(
-  inp: [G; IN_76],
+const INPUT_SIZE_80: usize = 10;
+const IN_80: usize = 10;
+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_76], 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];
@@ -10545,18 +10645,18 @@ fn aiur_fn_76(
     let __v_10: G = __r_arr[0];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_76] = [__v_0, __v_1];
-        record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_0, __v_1];
+        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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 __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_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 __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 __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
         let __v_18: G = __r_arr[2];
@@ -10565,11 +10665,11 @@ fn aiur_fn_76(
         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_76] = { let __args: [G; IN_76] = [__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[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_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 __v_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __ret: [G; OUT_76] = [__v_24, __v_25];
-        record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_24, __v_25];
+        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10579,15 +10679,15 @@ fn aiur_fn_76(
   })
 }
 
-const INPUT_SIZE_77: usize = 9;
-const IN_77: usize = 9;
-const OUT_77: usize = 2;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+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_77], 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];
@@ -10602,18 +10702,18 @@ fn aiur_fn_77(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_77] = [__v_10, __v_11];
-        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_81] = [__v_10, __v_11];
+        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        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 __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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -10622,14 +10722,14 @@ fn aiur_fn_77(
         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_77] = { let __args: [G; IN_77] = [__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[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_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 __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_77] = [__v_24, __v_21];
-        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_81] = [__v_24, __v_21];
+        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10639,15 +10739,15 @@ fn aiur_fn_77(
   })
 }
 
-const INPUT_SIZE_78: usize = 9;
-const IN_78: usize = 9;
-const OUT_78: usize = 2;
-fn aiur_fn_78(
-  inp: [G; IN_78],
+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_78], 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];
@@ -10662,18 +10762,18 @@ fn aiur_fn_78(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_78] = [__v_10, __v_11];
-        record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_10, __v_11];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        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 __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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -10682,14 +10782,14 @@ fn aiur_fn_78(
         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_78] = { let __args: [G; IN_78] = [__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[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_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(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_78] = [__v_24, __v_21];
-        record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_24, __v_21];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10699,18 +10799,18 @@ fn aiur_fn_78(
   })
 }
 
-const INPUT_SIZE_79: usize = 1;
-const IN_79: usize = 1;
-const OUT_79: usize = 2;
-fn aiur_fn_79(
-  inp: [G; IN_79],
+const INPUT_SIZE_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_79], 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_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_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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -10726,20 +10826,20 @@ fn aiur_fn_79(
         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_79] = [__v_13, __v_10];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_13, __v_10];
+        record.function_queries[83].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_79] = [__v_13, __v_10];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_13, __v_10];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10749,18 +10849,18 @@ fn aiur_fn_79(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+        let __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 __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_79] = [__v_24, __v_21];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_24, __v_21];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10770,18 +10870,18 @@ fn aiur_fn_79(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+        let __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 __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_79] = [__v_24, __v_21];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_24, __v_21];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10791,72 +10891,72 @@ fn aiur_fn_79(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !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_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 __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_79] = [__v_23, __v_21];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_23, __v_21];
+        record.function_queries[83].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_79] = [__v_13, __v_10];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_13, __v_10];
+        record.function_queries[83].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_79] = [__v_13, __v_10];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_13, __v_10];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__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[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_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 __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_79] = [__v_13, __v_14];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_13, __v_14];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__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[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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_79] = [__v_11, __v_12];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_11, __v_12];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
+        let __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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_79] = [__v_11, __v_12];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_11, __v_12];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__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[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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_79] = [__v_11, __v_12];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_11, __v_12];
+        record.function_queries[83].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_79] = [__v_13, __v_10];
-        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_13, __v_10];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10866,15 +10966,15 @@ fn aiur_fn_79(
   })
 }
 
-const INPUT_SIZE_80: usize = 9;
-const IN_80: usize = 9;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
+const INPUT_SIZE_84: usize = 9;
+const IN_84: usize = 9;
+const OUT_84: usize = 2;
+fn aiur_fn_84(
+  inp: [G; IN_84],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
+) -> Result<[G; OUT_84], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10885,33 +10985,33 @@ fn aiur_fn_80(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    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 __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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_12]; 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_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 __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_80] = [__v_17, __v_14];
-    record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_84] = [__v_17, __v_14];
+    record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_81: usize = 17;
-const IN_81: usize = 17;
-const OUT_81: usize = 9;
-fn aiur_fn_81(
-  inp: [G; IN_81],
+const INPUT_SIZE_85: usize = 17;
+const IN_85: usize = 17;
+const OUT_85: usize = 9;
+fn aiur_fn_85(
+  inp: [G; IN_85],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_81], ExecError> {
+) -> 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];
@@ -10934,12 +11034,12 @@ fn aiur_fn_81(
     let __v_17: G = __r_arr[0];
     match __v_17.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_81] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -10948,7 +11048,7 @@ fn aiur_fn_81(
         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_81] = { let __args: [G; IN_81] = [__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[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_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 __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -10961,8 +11061,8 @@ fn aiur_fn_81(
         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_81] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -10972,18 +11072,18 @@ fn aiur_fn_81(
   })
 }
 
-const INPUT_SIZE_82: usize = 1;
-const IN_82: usize = 1;
-const OUT_82: usize = 10;
-fn aiur_fn_82(
-  inp: [G; IN_82],
+const INPUT_SIZE_86: usize = 1;
+const IN_86: usize = 1;
+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_82], ExecError> {
+) -> Result<[G; OUT_86], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11002,12 +11102,12 @@ fn aiur_fn_82(
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_82] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
-            record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
@@ -11018,7 +11118,7 @@ fn aiur_fn_82(
             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_81] = { let __args: [G; IN_81] = [__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[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_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 __v_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
             let __v_24: G = __r_arr[2];
@@ -11028,8 +11128,8 @@ fn aiur_fn_82(
             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_82] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
-            record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -11038,7 +11138,7 @@ fn aiur_fn_82(
         }
       },
       1u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11049,7 +11149,7 @@ fn aiur_fn_82(
         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_82] = { let __args: [G; IN_82] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -11064,12 +11164,12 @@ fn aiur_fn_82(
         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_82] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11080,7 +11180,7 @@ fn aiur_fn_82(
         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_82] = { let __args: [G; IN_82] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -11095,14 +11195,14 @@ fn aiur_fn_82(
         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_82] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_82] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -11112,15 +11212,15 @@ 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_87: usize = 1;
+const IN_87: usize = 1;
+const OUT_87: usize = 2;
+fn aiur_fn_87(
+  inp: [G; IN_87],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_83], ExecError> {
+) -> Result<[G; OUT_87], 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 };
@@ -11316,8 +11416,8 @@ fn aiur_fn_83(
                                                                                                                                 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_83] = [__v_97, __v_96];
-                                                                                                                                    record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                    let __ret: [G; OUT_87] = [__v_97, __v_96];
+                                                                                                                                    record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                     return Ok(__ret);
                                                                                                                                   },
                                                                                                                                   _ => {
@@ -11482,15 +11582,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_88: usize = 9;
+const IN_88: usize = 9;
+const OUT_88: usize = 2;
+fn aiur_fn_88(
+  inp: [G; IN_88],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_84], ExecError> {
+) -> 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];
@@ -11508,15 +11608,15 @@ fn aiur_fn_84(
         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_84] = [__v_12, __v_0];
-        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_12, __v_0];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        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 __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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -11525,13 +11625,13 @@ fn aiur_fn_84(
         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_84] = { let __args: [G; IN_84] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __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 __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_84] = [__v_23, __v_21];
-        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_23, __v_21];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11541,15 +11641,15 @@ fn aiur_fn_84(
   })
 }
 
-const INPUT_SIZE_85: usize = 9;
-const IN_85: usize = 9;
-const OUT_85: usize = 2;
-fn aiur_fn_85(
-  inp: [G; IN_85],
+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_85], 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];
@@ -11567,12 +11667,12 @@ fn aiur_fn_85(
         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_85] = [__v_12, __v_0];
-        record.function_queries[85].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_82] = { let __args: [G; IN_82] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11583,7 +11683,7 @@ fn aiur_fn_85(
         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_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 __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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -11592,14 +11692,14 @@ fn aiur_fn_85(
         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_85] = { let __args: [G; IN_85] = [__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[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_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; 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_85] = [__v_32, __v_29];
-        record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_89] = [__v_32, __v_29];
+        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11609,15 +11709,15 @@ fn aiur_fn_85(
   })
 }
 
-const INPUT_SIZE_86: usize = 9;
-const IN_86: usize = 9;
-const OUT_86: usize = 2;
-fn aiur_fn_86(
-  inp: [G; IN_86],
+const INPUT_SIZE_90: usize = 9;
+const IN_90: usize = 9;
+const OUT_90: usize = 2;
+fn aiur_fn_90(
+  inp: [G; IN_90],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_86], ExecError> {
+) -> Result<[G; OUT_90], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11635,15 +11735,15 @@ fn aiur_fn_86(
         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_86] = [__v_12, __v_0];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_90] = [__v_12, __v_0];
+        record.function_queries[90].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_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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        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 __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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -11652,13 +11752,13 @@ fn aiur_fn_86(
         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_86] = { let __args: [G; IN_86] = [__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[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_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 __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_86] = [__v_23, __v_21];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_90] = [__v_23, __v_21];
+        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11668,18 +11768,18 @@ 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_91: usize = 1;
+const IN_91: usize = 1;
+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_87], 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_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11689,27 +11789,27 @@ fn aiur_fn_87(
     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_84] = { let __args: [G; IN_84] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_87] = [__v_10, __v_11];
-    record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_91] = [__v_10, __v_11];
+    record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_88: usize = 1;
-const IN_88: usize = 1;
-const OUT_88: usize = 2;
-fn aiur_fn_88(
-  inp: [G; IN_88],
+const INPUT_SIZE_92: usize = 1;
+const IN_92: usize = 1;
+const OUT_92: usize = 2;
+fn aiur_fn_92(
+  inp: [G; IN_92],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_88], ExecError> {
+) -> Result<[G; OUT_92], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11719,27 +11819,27 @@ fn aiur_fn_88(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__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[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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_88] = [__v_10, __v_11];
-    record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_92] = [__v_10, __v_11];
+    record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_89: usize = 1;
-const IN_89: usize = 1;
-const OUT_89: usize = 2;
-fn aiur_fn_89(
-  inp: [G; IN_89],
+const INPUT_SIZE_93: usize = 1;
+const IN_93: usize = 1;
+const OUT_93: usize = 2;
+fn aiur_fn_93(
+  inp: [G; IN_93],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_89], 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_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11749,88 +11849,88 @@ fn aiur_fn_89(
     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_85] = { let __args: [G; IN_85] = [__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[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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_89] = [__v_10, __v_11];
-    record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_93] = [__v_10, __v_11];
+    record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_90: usize = 1;
-const IN_90: usize = 1;
-const OUT_90: usize = 2;
-fn aiur_fn_90(
-  inp: [G; IN_90],
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 2;
+fn aiur_fn_94(
+  inp: [G; IN_94],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_90], ExecError> {
+) -> Result<[G; OUT_94], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].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_90] = [__v_1, __v_2];
-        record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1, __v_2];
+        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11840,24 +11940,24 @@ fn aiur_fn_90(
   })
 }
 
-const INPUT_SIZE_91: usize = 1;
-const IN_91: usize = 1;
-const OUT_91: usize = 13;
-fn aiur_fn_91(
-  inp: [G; IN_91],
+const INPUT_SIZE_95: usize = 1;
+const IN_95: usize = 1;
+const OUT_95: usize = 13;
+fn aiur_fn_95(
+  inp: [G; IN_95],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_91], ExecError> {
+) -> Result<[G; OUT_95], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = __r_arr[2];
@@ -11867,30 +11967,30 @@ fn aiur_fn_91(
     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_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 __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 __v_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_15]; 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_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 __v_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
-    let __ret: [G; OUT_91] = [__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[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_95] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17];
+    record.function_queries[95].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 = 10;
-fn aiur_fn_92(
-  inp: [G; IN_92],
+const INPUT_SIZE_96: usize = 1;
+const IN_96: usize = 1;
+const OUT_96: usize = 10;
+fn aiur_fn_96(
+  inp: [G; IN_96],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_92], 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_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11900,24 +12000,24 @@ 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_79] = { let __args: [G; IN_79] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_92] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_93: usize = 9;
-const IN_93: usize = 9;
-const OUT_93: usize = 2;
-fn aiur_fn_93(
-  inp: [G; IN_93],
+const INPUT_SIZE_97: usize = 9;
+const IN_97: usize = 9;
+const OUT_97: usize = 2;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_93], ExecError> {
+) -> Result<[G; OUT_97], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11935,12 +12035,12 @@ fn aiur_fn_93(
         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_93] = [__v_12, __v_0];
-        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_97] = [__v_12, __v_0];
+        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_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 __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11951,7 +12051,7 @@ fn aiur_fn_93(
         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_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 __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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -11960,13 +12060,13 @@ fn aiur_fn_93(
         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_93] = { let __args: [G; IN_93] = [__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[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_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 __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_93] = [__v_31, __v_29];
-        record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_97] = [__v_31, __v_29];
+        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11976,18 +12076,18 @@ fn aiur_fn_93(
   })
 }
 
-const INPUT_SIZE_94: usize = 1;
-const IN_94: usize = 1;
-const OUT_94: usize = 45;
-fn aiur_fn_94(
-  inp: [G; IN_94],
+const INPUT_SIZE_98: usize = 1;
+const IN_98: usize = 1;
+const OUT_98: usize = 45;
+fn aiur_fn_98(
+  inp: [G; IN_98],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_94], 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_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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) };
@@ -11999,7 +12099,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12009,7 +12109,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_19]; 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_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 __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -12019,7 +12119,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -12029,7 +12129,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -12039,7 +12139,7 @@ fn aiur_fn_94(
     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_72] = { let __args: [G; IN_72] = [__v_46]; 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_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 __v_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __v_49: G = __r_arr[2];
@@ -12049,10 +12149,10 @@ fn aiur_fn_94(
     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_79] = { let __args: [G; IN_79] = [__v_55]; 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_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 __v_56: G = __r_arr[0];
     let __v_57: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_57]; 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_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 __v_58: G = __r_arr[0];
     let __v_59: G = __r_arr[1];
     let __v_60: G = __r_arr[2];
@@ -12062,30 +12162,30 @@ fn aiur_fn_94(
     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_93] = { let __args: [G; IN_93] = [__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[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_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 __v_67: G = __r_arr[0];
     let __v_68: G = __r_arr[1];
-    let __ret: [G; OUT_94] = [__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[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_95: usize = 1;
-const IN_95: usize = 1;
-const OUT_95: usize = 11;
-fn aiur_fn_95(
-  inp: [G; IN_95],
+const INPUT_SIZE_99: usize = 1;
+const IN_99: usize = 1;
+const OUT_99: usize = 11;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_95], 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_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -12095,49 +12195,49 @@ fn aiur_fn_95(
     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_79] = { let __args: [G; IN_79] = [__v_11]; 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_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 __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
-    let __ret: [G; OUT_95] = [__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[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_96: usize = 1;
-const IN_96: usize = 1;
-const OUT_96: usize = 1;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_100: usize = 1;
+const IN_100: usize = 1;
+const OUT_100: usize = 1;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_100], 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_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_100] = [__v_1];
+        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_100] = [__v_1];
+        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_100] = [__v_1];
+        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(3);
-        let __ret: [G; OUT_96] = [__v_1];
-        record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_100] = [__v_1];
+        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12147,23 +12247,23 @@ fn aiur_fn_96(
   })
 }
 
-const INPUT_SIZE_97: usize = 1;
-const IN_97: usize = 1;
-const OUT_97: usize = 11;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_101: usize = 1;
+const IN_101: usize = 1;
+const OUT_101: usize = 11;
+fn aiur_fn_101(
+  inp: [G; IN_101],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; 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_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -12173,30 +12273,30 @@ fn aiur_fn_97(
     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_79] = { let __args: [G; IN_79] = [__v_12]; 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_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 __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __ret: [G; OUT_97] = [__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[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_98: usize = 1;
-const IN_98: usize = 1;
-const OUT_98: usize = 35;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_102: usize = 1;
+const IN_102: usize = 1;
+const OUT_102: usize = 35;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
+) -> Result<[G; OUT_102], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -12206,7 +12306,7 @@ fn aiur_fn_98(
     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_72] = { let __args: [G; IN_72] = [__v_11]; 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_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 __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -12216,7 +12316,7 @@ fn aiur_fn_98(
     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_72] = { let __args: [G; IN_72] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -12226,7 +12326,7 @@ fn aiur_fn_98(
     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_72] = { let __args: [G; IN_72] = [__v_29]; 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_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 __v_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = __r_arr[2];
@@ -12236,24 +12336,24 @@ fn aiur_fn_98(
     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_79] = { let __args: [G; IN_79] = [__v_38]; 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_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 __v_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
-    let __ret: [G; OUT_98] = [__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[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_99: usize = 9;
-const IN_99: usize = 9;
-const OUT_99: usize = 2;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_103: usize = 9;
+const IN_103: usize = 9;
+const OUT_103: usize = 2;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12271,12 +12371,12 @@ fn aiur_fn_99(
         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_99] = [__v_12, __v_0];
-        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_12, __v_0];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12312,7 +12412,7 @@ fn aiur_fn_99(
         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_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 __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 __v_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -12321,13 +12421,13 @@ fn aiur_fn_99(
         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_99] = { let __args: [G; IN_99] = [__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[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_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 __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_99] = [__v_56, __v_54];
-        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_56, __v_54];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12337,18 +12437,18 @@ fn aiur_fn_99(
   })
 }
 
-const INPUT_SIZE_100: usize = 1;
-const IN_100: usize = 1;
-const OUT_100: usize = 28;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_104: usize = 1;
+const IN_104: usize = 1;
+const OUT_104: usize = 28;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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) };
@@ -12360,7 +12460,7 @@ fn aiur_fn_100(
     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_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12370,7 +12470,7 @@ fn aiur_fn_100(
     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_72] = { let __args: [G; IN_72] = [__v_19]; 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_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 __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -12380,7 +12480,7 @@ fn aiur_fn_100(
     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_72] = { let __args: [G; IN_72] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -12390,10 +12490,10 @@ fn aiur_fn_100(
     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_79] = { let __args: [G; IN_79] = [__v_37]; 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_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 __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_39]; 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_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 __v_40: G = __r_arr[0];
     let __v_41: G = __r_arr[1];
     let __v_42: G = __r_arr[2];
@@ -12403,27 +12503,27 @@ fn aiur_fn_100(
     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_99] = { let __args: [G; IN_99] = [__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[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_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 __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __ret: [G; OUT_100] = [__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[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_101: usize = 1;
-const IN_101: usize = 1;
-const OUT_101: usize = 10;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+const INPUT_SIZE_105: usize = 1;
+const IN_105: usize = 1;
+const OUT_105: usize = 10;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -12433,27 +12533,27 @@ fn aiur_fn_101(
     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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_101] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_102: usize = 1;
-const IN_102: usize = 1;
-const OUT_102: usize = 18;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_106: usize = 1;
+const IN_106: usize = 1;
+const OUT_106: usize = 18;
+fn aiur_fn_106(
+  inp: [G; IN_106],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -12463,7 +12563,7 @@ fn aiur_fn_102(
     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_72] = { let __args: [G; IN_72] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -12473,32 +12573,32 @@ fn aiur_fn_102(
     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_83] = { let __args: [G; IN_83] = [__v_18]; 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_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 __v_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __ret: [G; OUT_102] = [__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[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_103: usize = 1;
-const IN_103: usize = 1;
-const OUT_103: usize = 46;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_107: usize = 1;
+const IN_107: usize = 1;
+const OUT_107: usize = 46;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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_91] = { let __args: [G; IN_91] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12514,12 +12614,12 @@ fn aiur_fn_103(
         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_103] = [__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[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       1u64 => {
-        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_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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12550,12 +12650,12 @@ fn aiur_fn_103(
         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_103] = [__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[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12602,8 +12702,8 @@ fn aiur_fn_103(
         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_103] = [__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[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -12613,15 +12713,15 @@ fn aiur_fn_103(
   })
 }
 
-const INPUT_SIZE_104: usize = 9;
-const IN_104: usize = 9;
-const OUT_104: usize = 2;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_108: usize = 9;
+const IN_108: usize = 9;
+const OUT_108: usize = 2;
+fn aiur_fn_108(
+  inp: [G; IN_108],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], 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];
@@ -12639,12 +12739,12 @@ fn aiur_fn_104(
         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_104] = [__v_12, __v_0];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__v_12, __v_0];
+        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; 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_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12691,7 +12791,7 @@ fn aiur_fn_104(
         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_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 __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 __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -12700,13 +12800,13 @@ fn aiur_fn_104(
         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_104] = { let __args: [G; IN_104] = [__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[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_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 __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_104] = [__v_67, __v_65];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_108] = [__v_67, __v_65];
+        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12716,21 +12816,21 @@ fn aiur_fn_104(
   })
 }
 
-const INPUT_SIZE_105: usize = 2;
-const IN_105: usize = 2;
-const OUT_105: usize = 46;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_109: usize = 2;
+const IN_109: usize = 2;
+const OUT_109: usize = 46;
+fn aiur_fn_109(
+  inp: [G; IN_109],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
+) -> Result<[G; OUT_109], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12746,12 +12846,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       1u64 => {
-        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_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];
@@ -12798,12 +12898,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        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_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12817,12 +12917,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12836,12 +12936,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; 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_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12862,12 +12962,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       5u64 => {
-        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_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12880,12 +12980,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       6u64 => {
-        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_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12898,12 +12998,12 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       7u64 => {
-        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_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12916,8 +13016,8 @@ fn aiur_fn_105(
         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_105] = [__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[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -12927,15 +13027,15 @@ fn aiur_fn_105(
   })
 }
 
-const INPUT_SIZE_106: usize = 10;
-const IN_106: usize = 10;
-const OUT_106: usize = 46;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_110: usize = 10;
+const IN_110: usize = 10;
+const OUT_110: usize = 46;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], 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];
@@ -12949,17 +13049,17 @@ fn aiur_fn_106(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       12u64 => {
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__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[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_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 __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_106] = [__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[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       13u64 => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_9]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -13006,8 +13106,8 @@ fn aiur_fn_106(
         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_106] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -13017,18 +13117,18 @@ fn aiur_fn_106(
   })
 }
 
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 49;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_111: usize = 1;
+const IN_111: usize = 1;
+const OUT_111: usize = 49;
+fn aiur_fn_111(
+  inp: [G; IN_111],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> Result<[G; OUT_111], 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_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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13039,7 +13139,7 @@ fn aiur_fn_107(
     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_106] = { let __args: [G; IN_106] = [__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[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_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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -13086,30 +13186,30 @@ fn aiur_fn_107(
     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_87] = { let __args: [G; IN_87] = [__v_56]; 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_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 __v_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_58]; 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_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 __v_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
-    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_60]; 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_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 __v_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
-    let __ret: [G; OUT_107] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_108: usize = 1;
-const IN_108: usize = 1;
-const OUT_108: usize = 1;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+const INPUT_SIZE_112: usize = 1;
+const IN_112: usize = 1;
+const OUT_112: usize = 1;
+fn aiur_fn_112(
+  inp: [G; IN_112],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_112], 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 };
@@ -13127,50 +13227,50 @@ fn aiur_fn_108(
         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_108] = [__v_12];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_112] = [__v_12];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__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 __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 __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_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_112] = [__v_13];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_10: G = G::from_u64(2);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__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 __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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3]; 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_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 __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_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_112] = [__v_13];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__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 __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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3]; 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_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 __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_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_112] = [__v_13];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(4);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __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 __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_108] = [__v_13];
-        record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_112] = [__v_13];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13180,15 +13280,15 @@ fn aiur_fn_108(
   })
 }
 
-const INPUT_SIZE_109: usize = 2;
-const IN_109: usize = 2;
-const OUT_109: usize = 1;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_113: usize = 2;
+const IN_113: usize = 2;
+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_109], 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];
@@ -13208,23 +13308,23 @@ fn aiur_fn_109(
         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_109] = [__v_14];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_113] = [__v_14];
+        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; 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_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 __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_13]; 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_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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_1]; 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_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 __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_109] = [__v_17];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_113] = [__v_17];
+        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13234,15 +13334,15 @@ fn aiur_fn_109(
   })
 }
 
-const INPUT_SIZE_110: usize = 1;
-const IN_110: usize = 1;
-const OUT_110: usize = 1;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_114: usize = 1;
+const IN_114: usize = 1;
+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_110], ExecError> {
+) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -13254,7 +13354,7 @@ fn aiur_fn_110(
     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_111] = { let __args: [G; IN_111] = [__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[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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -13264,7 +13364,7 @@ fn aiur_fn_110(
     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_112] = { let __args: [G; IN_112] = [__v_0, __v_18]; 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_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 __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];
@@ -13279,8 +13379,8 @@ fn aiur_fn_110(
             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_110] = [__v_26];
-            record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_114] = [__v_26];
+            record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -13289,8 +13389,8 @@ fn aiur_fn_110(
             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_110] = [__v_28];
-            record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_114] = [__v_28];
+            record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13299,27 +13399,27 @@ fn aiur_fn_110(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19]; 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_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 __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_110] = [__v_25];
-        record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_114] = [__v_25];
+        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_111: usize = 10;
-const IN_111: usize = 10;
-const OUT_111: usize = 8;
-fn aiur_fn_111(
-  inp: [G; IN_111],
+const INPUT_SIZE_115: usize = 10;
+const IN_115: usize = 10;
+const OUT_115: usize = 8;
+fn aiur_fn_115(
+  inp: [G; IN_115],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_111], 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];
@@ -13333,8 +13433,8 @@ fn aiur_fn_111(
     let __v_9: G = inp[9];
     match __v_9.as_canonical_u64() {
       8u64 => {
-        let __ret: [G; OUT_111] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -13344,15 +13444,15 @@ fn aiur_fn_111(
         let __v_12: G = __loaded[2];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_111] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-            record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           0u64 => {
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13361,13 +13461,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_13: G = G::from_u64(2);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13376,13 +13476,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               2u64 => {
                 let __v_13: G = G::from_u64(3);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13391,13 +13491,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               3u64 => {
                 let __v_13: G = G::from_u64(4);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13406,13 +13506,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               4u64 => {
                 let __v_13: G = G::from_u64(5);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13421,13 +13521,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               5u64 => {
                 let __v_13: G = G::from_u64(6);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13436,13 +13536,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               6u64 => {
                 let __v_13: G = G::from_u64(7);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13451,13 +13551,13 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -13466,8 +13566,8 @@ fn aiur_fn_111(
                 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_111] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -13481,22 +13581,22 @@ fn aiur_fn_111(
   })
 }
 
-const INPUT_SIZE_112: usize = 2;
-const IN_112: usize = 2;
-const OUT_112: usize = 1;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_116: usize = 2;
+const IN_116: usize = 2;
+const OUT_116: usize = 1;
+fn aiur_fn_116(
+  inp: [G; IN_116],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_112], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_112] = [__v_0];
-        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_116] = [__v_0];
+        record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -13509,17 +13609,17 @@ fn aiur_fn_112(
             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_112] = [__v_7];
-            record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_116] = [__v_7];
+            record.function_queries[116].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_112] = { let __args: [G; IN_112] = [__v_4, __v_6]; 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_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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_112] = [__v_7];
-            record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_116] = [__v_7];
+            record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13531,15 +13631,15 @@ fn aiur_fn_112(
   })
 }
 
-const INPUT_SIZE_113: usize = 6;
-const IN_113: usize = 6;
-const OUT_113: usize = 1;
-fn aiur_fn_113(
-  inp: [G; IN_113],
+const INPUT_SIZE_117: usize = 6;
+const IN_117: usize = 6;
+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_113], ExecError> {
+) -> 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];
@@ -13568,149 +13668,149 @@ fn aiur_fn_113(
     let __v_23: G = __loaded[17];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_24]; 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_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 __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(1);
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_25]; 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_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 __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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_29];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_24: G = G::from_u64(0);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __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_113] = [__v_27];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_27];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_24]; 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_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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __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 __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 __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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_29];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_24]; 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_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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __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 __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 __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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_29];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_24]; 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_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 __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(8);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_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[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_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 __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_23, __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 __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 __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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_29];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__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[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_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 __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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_28];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__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[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_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_24]; 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_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 __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_113] = [__v_29];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_29];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_24: G = G::from_u64(3);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __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 __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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_8, __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 __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 __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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_28];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_24: G = G::from_u64(4);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __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 __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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_8, __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 __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 __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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_28];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
         let __v_24: G = G::from_u64(5);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __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 __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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_8, __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 __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 __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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_28];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
         let __v_24: G = G::from_u64(6);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_15, __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 __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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__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 __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 __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_17, __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 __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 __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_113] = [__v_28];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_117] = [__v_28];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_1, __v_24]; 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_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 __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];
@@ -13718,10 +13818,10 @@ fn aiur_fn_113(
         let __v_28: G = __loaded[2];
         match __v_26.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_27, __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 __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 __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_113] = [__v_29];
-            record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_117] = [__v_29];
+            record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -13736,15 +13836,15 @@ fn aiur_fn_113(
   })
 }
 
-const INPUT_SIZE_114: usize = 7;
-const IN_114: usize = 7;
-const OUT_114: usize = 1;
-fn aiur_fn_114(
-  inp: [G; IN_114],
+const INPUT_SIZE_118: usize = 7;
+const IN_118: usize = 7;
+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_114], ExecError> {
+) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13770,8 +13870,8 @@ fn aiur_fn_114(
         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_114] = [__v_20];
-        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_118] = [__v_20];
+        record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -13785,16 +13885,16 @@ fn aiur_fn_114(
               0u64 => {
                 match __v_2.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+                    let __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 __v_21: G = __r_arr[0];
-                    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_22: G = __r_arr[0];
                     let __v_23: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __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 __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 __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_114] = [__v_25];
-                    record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_118] = [__v_25];
+                    record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -13813,15 +13913,15 @@ fn aiur_fn_114(
   })
 }
 
-const INPUT_SIZE_115: usize = 18;
-const IN_115: usize = 18;
-const OUT_115: usize = 11;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_119: usize = 18;
+const IN_119: usize = 18;
+const OUT_119: usize = 11;
+fn aiur_fn_119(
+  inp: [G; IN_119],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_115], ExecError> {
+) -> 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];
@@ -13845,51 +13945,51 @@ fn aiur_fn_115(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __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 __v_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __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 __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_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                let __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 __v_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(0);
-                let __ret: [G; OUT_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               1u64 => {
                 match __v_1.as_canonical_u64() {
                   0u64 => {
                     let __v_20: G = G::from_u64(3);
-                    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                    let __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 __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_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_20: G = G::from_u64(3);
-                    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                    let __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 __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_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
               },
               2u64 => {
                 let __v_20: G = G::from_u64(2);
-                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                let __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 __v_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(0);
-                let __ret: [G; OUT_115] = [__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[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -13903,15 +14003,15 @@ fn aiur_fn_115(
   })
 }
 
-const INPUT_SIZE_116: usize = 15;
-const IN_116: usize = 15;
-const OUT_116: usize = 11;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+const INPUT_SIZE_120: usize = 15;
+const IN_120: usize = 15;
+const OUT_120: usize = 11;
+fn aiur_fn_120(
+  inp: [G; IN_120],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_116], ExecError> {
+) -> 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];
@@ -13932,14 +14032,14 @@ fn aiur_fn_116(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __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 __v_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __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 __v_17: G = __r_arr[0];
             let __v_18: G = G::from_u64(0);
-            let __ret: [G; OUT_116] = [__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[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -13948,15 +14048,15 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 15;
-const IN_117: usize = 15;
-const OUT_117: usize = 11;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+const INPUT_SIZE_121: usize = 15;
+const IN_121: usize = 15;
+const OUT_121: usize = 11;
+fn aiur_fn_121(
+  inp: [G; IN_121],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_117], 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];
@@ -13977,14 +14077,14 @@ fn aiur_fn_117(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __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 __v_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(4);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __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 __v_17: G = __r_arr[0];
             let __v_18: G = G::from_u64(0);
-            let __ret: [G; OUT_117] = [__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[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -13993,15 +14093,15 @@ fn aiur_fn_117(
   })
 }
 
-const INPUT_SIZE_118: usize = 51;
-const IN_118: usize = 51;
-const OUT_118: usize = 11;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_122: usize = 51;
+const IN_122: usize = 51;
+const OUT_122: usize = 11;
+fn aiur_fn_122(
+  inp: [G; IN_122],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_118], 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];
@@ -14058,23 +14158,23 @@ fn aiur_fn_118(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_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 __v_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; 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_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 __v_52: G = __r_arr[0];
             let __v_53: G = G::from_u64(7);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __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 __v_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_55: G = __r_arr[0];
-            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_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 __v_56: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_58: G = __r_arr[0];
-            let __ret: [G; OUT_118] = [__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[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -14083,15 +14183,15 @@ fn aiur_fn_118(
   })
 }
 
-const INPUT_SIZE_119: usize = 34;
-const IN_119: usize = 34;
-const OUT_119: usize = 11;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+const INPUT_SIZE_123: usize = 34;
+const IN_123: usize = 34;
+const OUT_123: usize = 11;
+fn aiur_fn_123(
+  inp: [G; IN_123],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_119], ExecError> {
+) -> Result<[G; OUT_123], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14131,18 +14231,18 @@ fn aiur_fn_119(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_25, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_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 __v_34: G = __r_arr[0];
             let __v_35: G = G::from_u64(5);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __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 __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __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 __v_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_38: G = __r_arr[0];
             let __v_39: G = G::from_u64(0);
-            let __ret: [G; OUT_119] = [__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[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -14151,15 +14251,15 @@ fn aiur_fn_119(
   })
 }
 
-const INPUT_SIZE_120: usize = 40;
-const IN_120: usize = 40;
-const OUT_120: usize = 11;
-fn aiur_fn_120(
-  inp: [G; IN_120],
+const INPUT_SIZE_124: usize = 40;
+const IN_124: usize = 40;
+const OUT_124: usize = 11;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14205,20 +14305,20 @@ fn aiur_fn_120(
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; 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_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 __v_40: G = __r_arr[0];
             let __v_41: G = G::from_u64(6);
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __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 __v_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __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 __v_43: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_44: G = __r_arr[0];
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_45: G = __r_arr[0];
             let __v_46: G = G::from_u64(0);
-            let __ret: [G; OUT_120] = [__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[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -14227,15 +14327,15 @@ fn aiur_fn_120(
   })
 }
 
-const INPUT_SIZE_121: usize = 1;
-const IN_121: usize = 1;
-const OUT_121: usize = 11;
-fn aiur_fn_121(
-  inp: [G; IN_121],
+const INPUT_SIZE_125: usize = 1;
+const IN_125: usize = 1;
+const OUT_125: usize = 11;
+fn aiur_fn_125(
+  inp: [G; IN_125],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
+) -> Result<[G; OUT_125], 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 };
@@ -14295,7 +14395,7 @@ fn aiur_fn_121(
       _ => {
         match __v_6.as_canonical_u64() {
           0u64 => {
-            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_1, __v_2, __v_3, __v_4, __v_5, __v_19]; 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_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 __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14307,12 +14407,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           1u64 => {
-            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_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14324,12 +14424,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__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[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_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 __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14341,12 +14441,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14358,12 +14458,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           4u64 => {
-            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_19, __v_20, __v_21, __v_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[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_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 __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14375,12 +14475,12 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           5u64 => {
-            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_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
             let __v_55: G = __r_arr[2];
@@ -14392,8 +14492,8 @@ fn aiur_fn_121(
             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_121] = [__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[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -14405,15 +14505,15 @@ fn aiur_fn_121(
   })
 }
 
-const INPUT_SIZE_122: usize = 1;
-const IN_122: usize = 1;
-const OUT_122: usize = 1;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_126: usize = 1;
+const IN_126: usize = 1;
+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_122], ExecError> {
+) -> Result<[G; OUT_126], 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 };
@@ -14425,12 +14525,12 @@ fn aiur_fn_122(
         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_122] = [__v_6];
-        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_126] = [__v_6];
+        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; 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_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 __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = __r_arr[2];
@@ -14444,11 +14544,11 @@ fn aiur_fn_122(
         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_122] = { let __args: [G; IN_122] = [__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 __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 __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_122] = [__v_18];
-        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_126] = [__v_18];
+        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -14458,15 +14558,15 @@ fn aiur_fn_122(
   })
 }
 
-const INPUT_SIZE_123: usize = 1;
-const IN_123: usize = 1;
-const OUT_123: usize = 48;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_127: usize = 1;
+const IN_127: usize = 1;
+const OUT_127: usize = 48;
+fn aiur_fn_127(
+  inp: [G; IN_127],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
+) -> Result<[G; OUT_127], 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 };
@@ -14509,8 +14609,8 @@ fn aiur_fn_123(
     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_18] = { let __args: [G; IN_18] = [__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[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_107] = { let __args: [G; IN_107] = [__v_37]; 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_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 __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -14575,21 +14675,21 @@ fn aiur_fn_123(
     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_123] = [__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[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_124: usize = 1;
-const IN_124: usize = 1;
-const OUT_124: usize = 1;
-fn aiur_fn_124(
-  inp: [G; IN_124],
+const INPUT_SIZE_128: usize = 1;
+const IN_128: usize = 1;
+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_124], ExecError> {
+) -> Result<[G; OUT_128], 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 };
@@ -14632,22 +14732,22 @@ fn aiur_fn_124(
     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_18] = { let __args: [G; IN_18] = [__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[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 __ret: [G; OUT_124] = [__v_37];
-    record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_125: usize = 2;
-const IN_125: usize = 2;
-const OUT_125: usize = 1;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+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_125], 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];
@@ -14811,269 +14911,269 @@ fn aiur_fn_125(
                                                                                                                             match __v_96.as_canonical_u64() {
                                                                                                                               0u64 => {
                                                                                                                                 let __v_97: G = G::from_u64(1);
-                                                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                let __ret: [G; OUT_129] = [__v_97];
+                                                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                 return Ok(__ret);
                                                                                                                               },
                                                                                                                               _ => {
                                                                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                let __ret: [G; OUT_129] = [__v_97];
+                                                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                 return Ok(__ret);
                                                                                                                               },
                                                                                                                             }
                                                                                                                           },
                                                                                                                           _ => {
                                                                                                                             let __v_97: G = G::from_u64(0);
-                                                                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                            let __ret: [G; OUT_129] = [__v_97];
+                                                                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                             return Ok(__ret);
                                                                                                                           },
                                                                                                                         }
                                                                                                                       },
                                                                                                                       _ => {
                                                                                                                         let __v_97: G = G::from_u64(0);
-                                                                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                        let __ret: [G; OUT_129] = [__v_97];
+                                                                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                         return Ok(__ret);
                                                                                                                       },
                                                                                                                     }
                                                                                                                   },
                                                                                                                   _ => {
                                                                                                                     let __v_97: G = G::from_u64(0);
-                                                                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                    let __ret: [G; OUT_129] = [__v_97];
+                                                                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                     return Ok(__ret);
                                                                                                                   },
                                                                                                                 }
                                                                                                               },
                                                                                                               _ => {
                                                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                let __ret: [G; OUT_129] = [__v_97];
+                                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                 return Ok(__ret);
                                                                                                               },
                                                                                                             }
                                                                                                           },
                                                                                                           _ => {
                                                                                                             let __v_97: G = G::from_u64(0);
-                                                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                            let __ret: [G; OUT_129] = [__v_97];
+                                                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                             return Ok(__ret);
                                                                                                           },
                                                                                                         }
                                                                                                       },
                                                                                                       _ => {
                                                                                                         let __v_97: G = G::from_u64(0);
-                                                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                        let __ret: [G; OUT_129] = [__v_97];
+                                                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                         return Ok(__ret);
                                                                                                       },
                                                                                                     }
                                                                                                   },
                                                                                                   _ => {
                                                                                                     let __v_97: G = G::from_u64(0);
-                                                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                    let __ret: [G; OUT_129] = [__v_97];
+                                                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                     return Ok(__ret);
                                                                                                   },
                                                                                                 }
                                                                                               },
                                                                                               _ => {
                                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                let __ret: [G; OUT_129] = [__v_97];
+                                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                 return Ok(__ret);
                                                                                               },
                                                                                             }
                                                                                           },
                                                                                           _ => {
                                                                                             let __v_97: G = G::from_u64(0);
-                                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                            let __ret: [G; OUT_129] = [__v_97];
+                                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                             return Ok(__ret);
                                                                                           },
                                                                                         }
                                                                                       },
                                                                                       _ => {
                                                                                         let __v_97: G = G::from_u64(0);
-                                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                        let __ret: [G; OUT_129] = [__v_97];
+                                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                         return Ok(__ret);
                                                                                       },
                                                                                     }
                                                                                   },
                                                                                   _ => {
                                                                                     let __v_97: G = G::from_u64(0);
-                                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                    let __ret: [G; OUT_129] = [__v_97];
+                                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                     return Ok(__ret);
                                                                                   },
                                                                                 }
                                                                               },
                                                                               _ => {
                                                                                 let __v_97: G = G::from_u64(0);
-                                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                let __ret: [G; OUT_129] = [__v_97];
+                                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                 return Ok(__ret);
                                                                               },
                                                                             }
                                                                           },
                                                                           _ => {
                                                                             let __v_97: G = G::from_u64(0);
-                                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                            let __ret: [G; OUT_129] = [__v_97];
+                                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                             return Ok(__ret);
                                                                           },
                                                                         }
                                                                       },
                                                                       _ => {
                                                                         let __v_97: G = G::from_u64(0);
-                                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                        let __ret: [G; OUT_129] = [__v_97];
+                                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                         return Ok(__ret);
                                                                       },
                                                                     }
                                                                   },
                                                                   _ => {
                                                                     let __v_97: G = G::from_u64(0);
-                                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    let __ret: [G; OUT_129] = [__v_97];
+                                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                     return Ok(__ret);
                                                                   },
                                                                 }
                                                               },
                                                               _ => {
                                                                 let __v_97: G = G::from_u64(0);
-                                                                let __ret: [G; OUT_125] = [__v_97];
-                                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                let __ret: [G; OUT_129] = [__v_97];
+                                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                 return Ok(__ret);
                                                               },
                                                             }
                                                           },
                                                           _ => {
                                                             let __v_97: G = G::from_u64(0);
-                                                            let __ret: [G; OUT_125] = [__v_97];
-                                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_129] = [__v_97];
+                                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                         }
                                                       },
                                                       _ => {
                                                         let __v_97: G = G::from_u64(0);
-                                                        let __ret: [G; OUT_125] = [__v_97];
-                                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        let __ret: [G; OUT_129] = [__v_97];
+                                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                         return Ok(__ret);
                                                       },
                                                     }
                                                   },
                                                   _ => {
                                                     let __v_97: G = G::from_u64(0);
-                                                    let __ret: [G; OUT_125] = [__v_97];
-                                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_129] = [__v_97];
+                                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                 }
                                               },
                                               _ => {
                                                 let __v_97: G = G::from_u64(0);
-                                                let __ret: [G; OUT_125] = [__v_97];
-                                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_129] = [__v_97];
+                                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
                                           },
                                           _ => {
                                             let __v_97: G = G::from_u64(0);
-                                            let __ret: [G; OUT_125] = [__v_97];
-                                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_129] = [__v_97];
+                                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
                                         let __v_97: G = G::from_u64(0);
-                                        let __ret: [G; OUT_125] = [__v_97];
-                                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_129] = [__v_97];
+                                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
                                     let __v_97: G = G::from_u64(0);
-                                    let __ret: [G; OUT_125] = [__v_97];
-                                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_129] = [__v_97];
+                                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_97: G = G::from_u64(0);
-                                let __ret: [G; OUT_125] = [__v_97];
-                                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_129] = [__v_97];
+                                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_97: G = G::from_u64(0);
-                            let __ret: [G; OUT_125] = [__v_97];
-                            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_129] = [__v_97];
+                            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_97: G = G::from_u64(0);
-                        let __ret: [G; OUT_125] = [__v_97];
-                        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_129] = [__v_97];
+                        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_97: G = G::from_u64(0);
-                    let __ret: [G; OUT_125] = [__v_97];
-                    record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_129] = [__v_97];
+                    record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_97: G = G::from_u64(0);
-                let __ret: [G; OUT_125] = [__v_97];
-                record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_129] = [__v_97];
+                record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_97: G = G::from_u64(0);
-            let __ret: [G; OUT_125] = [__v_97];
-            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_129] = [__v_97];
+            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_97: G = G::from_u64(0);
-        let __ret: [G; OUT_125] = [__v_97];
-        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_129] = [__v_97];
+        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_126: usize = 2;
-const IN_126: usize = 2;
-const OUT_126: usize = 1;
-fn aiur_fn_126(
-  inp: [G; IN_126],
+const INPUT_SIZE_130: usize = 2;
+const IN_130: usize = 2;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_126], 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];
@@ -15146,31 +15246,31 @@ fn aiur_fn_126(
     let __v_66: G = (__v_2 - __v_34);
     match __v_66.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __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 __v_67: G = __r_arr[0];
-        let __ret: [G; OUT_126] = [__v_67];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_130] = [__v_67];
+        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_67: G = G::from_u64(0);
-        let __ret: [G; OUT_126] = [__v_67];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_130] = [__v_67];
+        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_127: usize = 1;
-const IN_127: usize = 1;
-const OUT_127: usize = 1;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_131: usize = 1;
+const IN_131: usize = 1;
+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_127], ExecError> {
+) -> Result<[G; OUT_131], 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 };
@@ -15219,8 +15319,8 @@ fn aiur_fn_127(
     let __v_40: G = __loaded[2];
     match __v_38.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_127] = [__v_39];
-        record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_131] = [__v_39];
+        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15230,32 +15330,32 @@ fn aiur_fn_127(
   })
 }
 
-const INPUT_SIZE_128: usize = 0;
-const IN_128: usize = 0;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+const INPUT_SIZE_132: usize = 0;
+const IN_132: usize = 0;
+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_128], ExecError> {
+) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(4294967295);
-    let __ret: [G; OUT_128] = [__v_0];
-    record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_132] = [__v_0];
+    record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_129: usize = 45;
-const IN_129: usize = 45;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+const INPUT_SIZE_133: usize = 45;
+const IN_133: usize = 45;
+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_129], 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];
@@ -15306,8 +15406,8 @@ fn aiur_fn_129(
       6u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_9];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_133] = [__v_9];
+            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15315,8 +15415,8 @@ fn aiur_fn_129(
       4u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_17];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_133] = [__v_17];
+            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15324,8 +15424,8 @@ fn aiur_fn_129(
       5u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_9];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_133] = [__v_9];
+            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15333,8 +15433,8 @@ fn aiur_fn_129(
       7u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __ret: [G; OUT_129] = [__v_9];
-            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_133] = [__v_9];
+            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -15373,8 +15473,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_133] = [__v_77];
+        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -15411,8 +15511,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_133] = [__v_77];
+        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -15449,8 +15549,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_133] = [__v_77];
+        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
@@ -15487,8 +15587,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_133] = [__v_77];
+        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
@@ -15525,8 +15625,8 @@ fn aiur_fn_129(
         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_129] = [__v_77];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_133] = [__v_77];
+        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15536,15 +15636,15 @@ fn aiur_fn_129(
   })
 }
 
-const INPUT_SIZE_130: usize = 45;
-const IN_130: usize = 45;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+const INPUT_SIZE_134: usize = 45;
+const IN_134: usize = 45;
+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_130], 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];
@@ -15595,26 +15695,26 @@ fn aiur_fn_130(
       1u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_27]; 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_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 __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_130] = [__v_47];
-            record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_134] = [__v_47];
+            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
         let __v_45: G = G::from_u64(1);
-        let __ret: [G; OUT_130] = [__v_45];
-        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_134] = [__v_45];
+        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_45: G = G::from_u64(1);
-        let __ret: [G; OUT_130] = [__v_45];
-        record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_134] = [__v_45];
+        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15624,15 +15724,15 @@ fn aiur_fn_130(
   })
 }
 
-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_135: usize = 1;
+const IN_135: usize = 1;
+const OUT_135: usize = 1;
+fn aiur_fn_135(
+  inp: [G; IN_135],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_131], ExecError> {
+) -> Result<[G; OUT_135], 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 };
@@ -15686,18 +15786,18 @@ fn aiur_fn_131(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_131] = [__v_48];
-        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_135] = [__v_48];
+        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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[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_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 __v_48: G = __r_arr[0];
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_47]; 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 __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 __v_49: G = __r_arr[0];
         let __v_50: G = (__v_48 + __v_49);
-        let __ret: [G; OUT_131] = [__v_50];
-        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_135] = [__v_50];
+        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15707,23 +15807,23 @@ fn aiur_fn_131(
   })
 }
 
-const INPUT_SIZE_132: usize = 2;
-const IN_132: usize = 2;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
+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_132], 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];
     match __v_1.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));
+        let __ret: [G; OUT_136] = [__v_2];
+        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -15777,15 +15877,15 @@ fn aiur_fn_132(
         let __v_48: G = __loaded[46];
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __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_132] = { let __args: [G; IN_132] = [__v_48, __v_51]; 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_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 __v_52: G = __r_arr[0];
             let __v_53: G = (__v_49 + __v_52);
-            let __ret: [G; OUT_132] = [__v_53];
-            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_136] = [__v_53];
+            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -15797,15 +15897,15 @@ fn aiur_fn_132(
   })
 }
 
-const INPUT_SIZE_133: usize = 2;
-const IN_133: usize = 2;
-const OUT_133: usize = 1;
-fn aiur_fn_133(
-  inp: [G; IN_133],
+const INPUT_SIZE_137: usize = 2;
+const IN_137: usize = 2;
+const OUT_137: usize = 1;
+fn aiur_fn_137(
+  inp: [G; IN_137],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_133], 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];
@@ -15816,35 +15916,35 @@ fn aiur_fn_133(
     let __v_5: G = __loaded[3];
     let __v_6: G = __loaded[4];
     let __v_7: G = __loaded[5];
-    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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 __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_133] = [__v_9];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_137] = [__v_9];
+        record.function_queries[137].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_133] = [__v_10];
-        record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_137] = [__v_10];
+        record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_134: usize = 2;
-const IN_134: usize = 2;
-const OUT_134: usize = 6;
-fn aiur_fn_134(
-  inp: [G; IN_134],
+const INPUT_SIZE_138: usize = 2;
+const IN_138: usize = 2;
+const OUT_138: usize = 6;
+fn aiur_fn_138(
+  inp: [G; IN_138],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_134], ExecError> {
+) -> 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];
@@ -15856,8 +15956,8 @@ fn aiur_fn_134(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_134] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -15869,22 +15969,22 @@ fn aiur_fn_134(
           0u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_6 + __v_8);
-            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_4, __v_7]; 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_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 __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_784] = { let __args: [G; IN_784] = [__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[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_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 __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_134] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -15899,15 +15999,15 @@ fn aiur_fn_134(
   })
 }
 
-const INPUT_SIZE_135: usize = 7;
-const IN_135: usize = 7;
-const OUT_135: usize = 6;
-fn aiur_fn_135(
-  inp: [G; IN_135],
+const INPUT_SIZE_139: usize = 7;
+const IN_139: usize = 7;
+const OUT_139: usize = 6;
+fn aiur_fn_139(
+  inp: [G; IN_139],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_135], 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];
@@ -15922,8 +16022,8 @@ fn aiur_fn_135(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_135] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -15978,22 +16078,22 @@ fn aiur_fn_135(
         let __v_57: G = __loaded[47];
         match __v_10.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_135] = { let __args: [G; IN_135] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; 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_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 __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_135] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69];
-            record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -16005,15 +16105,15 @@ fn aiur_fn_135(
   })
 }
 
-const INPUT_SIZE_136: usize = 7;
-const IN_136: usize = 7;
-const OUT_136: usize = 6;
-fn aiur_fn_136(
-  inp: [G; IN_136],
+const INPUT_SIZE_140: usize = 7;
+const IN_140: usize = 7;
+const OUT_140: usize = 6;
+fn aiur_fn_140(
+  inp: [G; IN_140],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_136], 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];
@@ -16028,46 +16128,46 @@ fn aiur_fn_136(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_136] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__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[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_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 __v_11: G = __r_arr[0];
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = []; 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_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 __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__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[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_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 __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_136] = { let __args: [G; IN_136] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_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 __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_136] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24];
-            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_136] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17];
-            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -16079,42 +16179,42 @@ fn aiur_fn_136(
   })
 }
 
-const INPUT_SIZE_137: usize = 2;
-const IN_137: usize = 2;
-const OUT_137: usize = 6;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+const INPUT_SIZE_141: usize = 2;
+const IN_141: usize = 2;
+const OUT_141: usize = 6;
+fn aiur_fn_141(
+  inp: [G; IN_141],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_137], 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];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
-    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__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[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_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 __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_137] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-    record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_138: usize = 8;
-const IN_138: usize = 8;
-const OUT_138: usize = 6;
-fn aiur_fn_138(
-  inp: [G; IN_138],
+const INPUT_SIZE_142: usize = 8;
+const IN_142: usize = 8;
+const OUT_142: usize = 6;
+fn aiur_fn_142(
+  inp: [G; IN_142],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_138], 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];
@@ -16130,8 +16230,8 @@ fn aiur_fn_138(
     let __v_10: G = __loaded[2];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_138] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -16141,22 +16241,22 @@ fn aiur_fn_138(
         let __v_13: G = __loaded[2];
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__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[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_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 __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_138] = { let __args: [G; IN_138] = [__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[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_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 __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_138] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-            record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -16171,15 +16271,15 @@ fn aiur_fn_138(
   })
 }
 
-const INPUT_SIZE_139: usize = 2;
-const IN_139: usize = 2;
-const OUT_139: usize = 1;
-fn aiur_fn_139(
-  inp: [G; IN_139],
+const INPUT_SIZE_143: usize = 2;
+const IN_143: usize = 2;
+const OUT_143: usize = 1;
+fn aiur_fn_143(
+  inp: [G; IN_143],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_139], 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];
@@ -16190,23 +16290,23 @@ fn aiur_fn_139(
     let __v_5: G = __loaded[3];
     let __v_6: G = __loaded[4];
     let __v_7: G = __loaded[5];
-    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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 __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_139] = [__v_8];
-    record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_143] = [__v_8];
+    record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_140: usize = 2;
-const IN_140: usize = 2;
-const OUT_140: usize = 1;
-fn aiur_fn_140(
-  inp: [G; IN_140],
+const INPUT_SIZE_144: usize = 2;
+const IN_144: usize = 2;
+const OUT_144: usize = 1;
+fn aiur_fn_144(
+  inp: [G; IN_144],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_140], 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];
@@ -16217,8 +16317,8 @@ fn aiur_fn_140(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_140] = [__v_5];
-        record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_144] = [__v_5];
+        record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16226,15 +16326,15 @@ fn aiur_fn_140(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_140] = [__v_6];
-            record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_144] = [__v_6];
+            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_4]; 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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_140] = [__v_6];
-            record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_144] = [__v_6];
+            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16246,15 +16346,15 @@ fn aiur_fn_140(
   })
 }
 
-const INPUT_SIZE_141: usize = 48;
-const IN_141: usize = 48;
-const OUT_141: usize = 1;
-fn aiur_fn_141(
-  inp: [G; IN_141],
+const INPUT_SIZE_145: usize = 48;
+const IN_145: usize = 48;
+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_141], ExecError> {
+) -> 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];
@@ -16308,19 +16408,19 @@ fn aiur_fn_141(
       _ => {
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1]; 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_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 __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_141] = [__v_49];
-                record.function_queries[141].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);
               },
               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_141] = [__v_49];
-                record.function_queries[141].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);
               },
               _ => {
@@ -16330,8 +16430,8 @@ fn aiur_fn_141(
           },
           _ => {
             let __v_48: G = G::from_u64(0);
-            let __ret: [G; OUT_141] = [__v_48];
-            record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_145] = [__v_48];
+            record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -16340,15 +16440,15 @@ fn aiur_fn_141(
   })
 }
 
-const INPUT_SIZE_142: usize = 1;
-const IN_142: usize = 1;
-const OUT_142: usize = 1;
-fn aiur_fn_142(
-  inp: [G; IN_142],
+const INPUT_SIZE_146: usize = 1;
+const IN_146: usize = 1;
+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_142], ExecError> {
+) -> Result<[G; OUT_146], 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 };
@@ -16454,45 +16554,45 @@ fn aiur_fn_142(
             match __v_2.as_canonical_u64() {
               1u64 => {
                 let __v_95: G = G::from_u64(1);
-                let __ret: [G; OUT_142] = [__v_95];
-                record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_146] = [__v_95];
+                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_95: G = G::from_u64(0);
-                let __ret: [G; OUT_142] = [__v_95];
-                record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_146] = [__v_95];
+                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_95: G = G::from_u64(0);
-            let __ret: [G; OUT_142] = [__v_95];
-            record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_146] = [__v_95];
+            record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_142] = [__v_48];
-        record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_146] = [__v_48];
+        record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_143: usize = 3;
-const IN_143: usize = 3;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
+const INPUT_SIZE_147: usize = 3;
+const IN_147: usize = 3;
+const OUT_147: usize = 1;
+fn aiur_fn_147(
+  inp: [G; IN_147],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_143], 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];
@@ -16504,8 +16604,8 @@ fn aiur_fn_143(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_143] = [__v_6];
-        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_147] = [__v_6];
+        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16518,15 +16618,15 @@ fn aiur_fn_143(
             let __v_9: G = (__v_4 - __v_0);
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_143] = [__v_7];
-                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_147] = [__v_7];
+                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                let __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 __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_143] = [__v_10];
-                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_147] = [__v_10];
+                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -16543,15 +16643,15 @@ fn aiur_fn_143(
   })
 }
 
-const INPUT_SIZE_144: usize = 3;
-const IN_144: usize = 3;
-const OUT_144: usize = 3;
-fn aiur_fn_144(
-  inp: [G; IN_144],
+const INPUT_SIZE_148: usize = 3;
+const IN_148: usize = 3;
+const OUT_148: usize = 3;
+fn aiur_fn_148(
+  inp: [G; IN_148],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_144], 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];
@@ -16562,25 +16662,25 @@ fn aiur_fn_144(
     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_145] = { let __args: [G; IN_145] = [__v_0, __v_1, __v_2, __v_5, __v_8]; 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_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 __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
-    let __ret: [G; OUT_144] = [__v_9, __v_10, __v_11];
-    record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_148] = [__v_9, __v_10, __v_11];
+    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_145: usize = 5;
-const IN_145: usize = 5;
-const OUT_145: usize = 3;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+const INPUT_SIZE_149: usize = 5;
+const IN_149: usize = 5;
+const OUT_149: usize = 3;
+fn aiur_fn_149(
+  inp: [G; IN_149],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_145], 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];
@@ -16599,8 +16699,8 @@ fn aiur_fn_145(
         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_145] = [__v_10, __v_13, __v_2];
-        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_149] = [__v_10, __v_13, __v_2];
+        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16663,7 +16763,7 @@ fn aiur_fn_145(
               _ => {
                 match __v_8.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_59: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_59.as_canonical_u64() {
   0u64 => {
@@ -16671,7 +16771,7 @@ fn aiur_fn_145(
     break '__mc_0 [__v_60];
   },
   _ => {
-    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_59, __v_3]; 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_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 __v_60: G = __r_arr[0];
     break '__mc_0 [__v_60];
   },
@@ -16680,9 +16780,9 @@ fn aiur_fn_145(
                     let __v_60: G = __mc_out___mc_0[0];
                     match __v_60.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_59, __v_3, __v_4]; 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_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 __v_61: G = __r_arr[0];
-                        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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_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 __v_62: G = __r_arr[0];
                         let __v_63: G = __r_arr[1];
                         let __v_64: G = __r_arr[2];
@@ -16690,12 +16790,12 @@ fn aiur_fn_145(
                         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_145] = [__v_66, __v_68, __v_64];
-                        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_149] = [__v_66, __v_68, __v_64];
+                        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_9]; 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 __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 __v_61: G = __r_arr[0];
                         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() {
   0u64 => {
@@ -16722,7 +16822,7 @@ fn aiur_fn_145(
  };
                         let __v_63: G = __mc_out___mc_2[0];
                         let __v_64: G = (__v_2 + __v_61);
-                        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_64, __v_62, __v_63]; 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_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 __v_65: G = __r_arr[0];
                         let __v_66: G = __r_arr[1];
                         let __v_67: G = __r_arr[2];
@@ -16730,8 +16830,8 @@ fn aiur_fn_145(
                         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_145] = [__v_69, __v_71, __v_67];
-                        record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_149] = [__v_69, __v_71, __v_67];
+                        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -16740,83 +16840,83 @@ fn aiur_fn_145(
                     }
                   },
                   6u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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_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 __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_59, __v_60, __v_61];
+                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   4u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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_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 __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_59, __v_60, __v_61];
+                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   5u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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_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 __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_59, __v_60, __v_61];
+                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   7u64 => {
-                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_2, __v_3, __v_4]; 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_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 __v_59: G = __r_arr[0];
                     let __v_60: G = __r_arr[1];
                     let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_59, __v_60, __v_61];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_59, __v_60, __v_61];
+                    record.function_queries[149].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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_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 __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_61, __v_62, __v_63];
+                    record.function_queries[149].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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_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 __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_61, __v_62, __v_63];
+                    record.function_queries[149].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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_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 __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_61, __v_62, __v_63];
+                    record.function_queries[149].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_145] = { let __args: [G; IN_145] = [__v_7, __v_58, __v_60, __v_3, __v_4]; 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_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 __v_61: G = __r_arr[0];
                     let __v_62: G = __r_arr[1];
                     let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_145] = [__v_61, __v_62, __v_63];
-                    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_149] = [__v_61, __v_62, __v_63];
+                    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -16838,15 +16938,15 @@ fn aiur_fn_145(
   })
 }
 
-const INPUT_SIZE_146: usize = 4;
-const IN_146: usize = 4;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+const INPUT_SIZE_150: usize = 4;
+const IN_150: usize = 4;
+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_146], 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];
@@ -16858,23 +16958,23 @@ fn aiur_fn_146(
     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_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; 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_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 __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_146] = [__v_10];
-    record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_150] = [__v_10];
+    record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_147: usize = 6;
-const IN_147: usize = 6;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
+const INPUT_SIZE_151: usize = 6;
+const IN_151: usize = 6;
+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_147], 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];
@@ -16891,8 +16991,8 @@ fn aiur_fn_147(
         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_147] = [__v_11];
-        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_151] = [__v_11];
+        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -16955,7 +17055,7 @@ fn aiur_fn_147(
               _ => {
                 match __v_9.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_60: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_60.as_canonical_u64() {
   0u64 => {
@@ -16963,7 +17063,7 @@ fn aiur_fn_147(
     break '__mc_0 [__v_61];
   },
   _ => {
-    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_60, __v_4]; 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_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 __v_61: G = __r_arr[0];
     break '__mc_0 [__v_61];
   },
@@ -16972,18 +17072,18 @@ fn aiur_fn_147(
                     let __v_61: G = __mc_out___mc_0[0];
                     match __v_61.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_60, __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 __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 __v_62: G = __r_arr[0];
                         let __v_63: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __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_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 __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_147] = [__v_65];
-                        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_151] = [__v_65];
+                        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_10]; 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 __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 __v_62: G = __r_arr[0];
                         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_60.as_canonical_u64() {
   0u64 => {
@@ -17011,11 +17111,11 @@ fn aiur_fn_147(
                         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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; 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_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 __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_147] = [__v_68];
-                        record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_151] = [__v_68];
+                        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -17026,9 +17126,9 @@ fn aiur_fn_147(
                   6u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18, __v_2]; 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_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 __v_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_18]; 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_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 __v_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17081,17 +17181,17 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; 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_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 __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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __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_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 __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_147] = [__v_114];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_151] = [__v_114];
+                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17106,9 +17206,9 @@ fn aiur_fn_147(
                   4u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_26, __v_2]; 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_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 __v_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_26]; 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_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 __v_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17161,22 +17261,22 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; 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_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 __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_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_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 __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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __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_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 __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_147] = [__v_118];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_151] = [__v_118];
+                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17191,9 +17291,9 @@ fn aiur_fn_147(
                   5u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18, __v_2]; 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_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 __v_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_18]; 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_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 __v_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17246,17 +17346,17 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; 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_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 __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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __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_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 __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_147] = [__v_114];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_151] = [__v_114];
+                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17271,9 +17371,9 @@ fn aiur_fn_147(
                   7u64 => {
                     match __v_10.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_18, __v_2]; 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_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 __v_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_18]; 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_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 __v_61: G = __r_arr[0];
                         let __v_62: G = __r_arr[1];
                         let __v_63: G = __r_arr[2];
@@ -17326,17 +17426,17 @@ fn aiur_fn_147(
                           _ => {
                             match __v_61.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_62, __v_109]; 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_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 __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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_3, __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_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 __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_147] = [__v_114];
-                                record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_151] = [__v_114];
+                                record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -17352,11 +17452,11 @@ fn aiur_fn_147(
                     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_147] = { let __args: [G; IN_147] = [__v_8, __v_59, __v_2, __v_62, __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_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 __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_147] = [__v_64];
-                    record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_151] = [__v_64];
+                    record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -17375,15 +17475,15 @@ fn aiur_fn_147(
   })
 }
 
-const INPUT_SIZE_148: usize = 2;
-const IN_148: usize = 2;
-const OUT_148: usize = 2;
-fn aiur_fn_148(
-  inp: [G; IN_148],
+const INPUT_SIZE_152: usize = 2;
+const IN_152: usize = 2;
+const OUT_152: usize = 2;
+fn aiur_fn_152(
+  inp: [G; IN_152],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_148], 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];
@@ -17399,12 +17499,12 @@ fn aiur_fn_148(
         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_148] = [__v_7, __v_10];
-        record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_152] = [__v_7, __v_10];
+        record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !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_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 __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 };
@@ -17414,19 +17514,19 @@ fn aiur_fn_148(
         let __v_10: G = __loaded[3];
         let __v_11: G = __loaded[4];
         let __v_12: G = __loaded[5];
-        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_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 __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           4294967295u64 => {
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+            let __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 __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_148] = [__v_17, __v_19];
-            record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_152] = [__v_17, __v_19];
+            record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -17439,8 +17539,8 @@ fn aiur_fn_148(
             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_148] = [__v_17, __v_22];
-            record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_152] = [__v_17, __v_22];
+            record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -17452,15 +17552,15 @@ fn aiur_fn_148(
   })
 }
 
-const INPUT_SIZE_149: usize = 1;
-const IN_149: usize = 1;
-const OUT_149: usize = 1;
-fn aiur_fn_149(
-  inp: [G; IN_149],
+const INPUT_SIZE_153: usize = 1;
+const IN_153: usize = 1;
+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_149], ExecError> {
+) -> Result<[G; OUT_153], 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 };
@@ -17516,18 +17616,18 @@ fn aiur_fn_149(
       _ => {
         match __v_1.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_2]; 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_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 __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_149] = [__v_50];
-                record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_153] = [__v_50];
+                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __ret: [G; OUT_149] = [__v_0];
-                record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_153] = [__v_0];
+                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -17537,8 +17637,8 @@ fn aiur_fn_149(
           },
           _ => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_149] = [__v_49];
-            record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_153] = [__v_49];
+            record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -17547,15 +17647,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_154: usize = 4;
+const IN_154: usize = 4;
+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_150], 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];
@@ -17567,8 +17667,8 @@ fn aiur_fn_150(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_150] = [__v_3];
-        record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_154] = [__v_3];
+        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17581,15 +17681,15 @@ fn aiur_fn_150(
             let __v_10: G = (__v_5 - __v_0);
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_150] = [__v_8];
-                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_154] = [__v_8];
+                record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_6, __v_9, __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 __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 __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_150] = [__v_11];
-                record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_154] = [__v_11];
+                record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -17606,15 +17706,15 @@ fn aiur_fn_150(
   })
 }
 
-const INPUT_SIZE_151: usize = 4;
-const IN_151: usize = 4;
-const OUT_151: usize = 1;
-fn aiur_fn_151(
-  inp: [G; IN_151],
+const INPUT_SIZE_155: usize = 4;
+const IN_155: usize = 4;
+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_151], 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];
@@ -17629,8 +17729,8 @@ fn aiur_fn_151(
         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_151] = [__v_9];
-        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_155] = [__v_9];
+        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -17640,14 +17740,14 @@ fn aiur_fn_151(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_5]; 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_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 __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_150] = { let __args: [G; IN_150] = [__v_10, __v_2, __v_3, __v_8]; 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_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 __v_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -17679,11 +17779,11 @@ fn aiur_fn_151(
  };
             let __v_13: G = __mc_out___mc_2[0];
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_6, __v_9, __v_12, __v_13]; 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_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 __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_151] = [__v_16];
-            record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_155] = [__v_16];
+            record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -17698,15 +17798,15 @@ fn aiur_fn_151(
   })
 }
 
-const INPUT_SIZE_152: usize = 2;
-const IN_152: usize = 2;
-const OUT_152: usize = 1;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+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_152], 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];
@@ -17716,23 +17816,23 @@ fn aiur_fn_152(
     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_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_4, __v_7]; 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_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 __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_152] = [__v_8];
-    record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_156] = [__v_8];
+    record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_153: usize = 10;
-const IN_153: usize = 10;
-const OUT_153: usize = 6;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+const INPUT_SIZE_157: usize = 10;
+const IN_157: usize = 10;
+const OUT_157: usize = 6;
+fn aiur_fn_157(
+  inp: [G; IN_157],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_153], ExecError> {
+) -> 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];
@@ -17750,8 +17850,8 @@ fn aiur_fn_153(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_153] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -17761,44 +17861,44 @@ fn aiur_fn_153(
         let __v_15: G = __loaded[2];
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_14]; 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_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 __v_16: G = __r_arr[0];
             match __v_16.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__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[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_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 __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_153] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_16, __v_2, __v_3, __v_11]; 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_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 __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_784] = { let __args: [G; IN_784] = [__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[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_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 __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_153] = { let __args: [G; IN_153] = [__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[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_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 __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_153] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -17815,15 +17915,15 @@ fn aiur_fn_153(
   })
 }
 
-const INPUT_SIZE_154: usize = 2;
-const IN_154: usize = 2;
-const OUT_154: usize = 6;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+const INPUT_SIZE_158: usize = 2;
+const IN_158: usize = 2;
+const OUT_158: usize = 6;
+fn aiur_fn_158(
+  inp: [G; IN_158],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], 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];
@@ -17835,28 +17935,28 @@ fn aiur_fn_154(
     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_153] = { let __args: [G; IN_153] = [__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[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_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 __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_154] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-    record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_155: usize = 2;
-const IN_155: usize = 2;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
+const INPUT_SIZE_159: usize = 2;
+const IN_159: usize = 2;
+const OUT_159: usize = 1;
+fn aiur_fn_159(
+  inp: [G; IN_159],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_155], 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];
@@ -17869,8 +17969,8 @@ fn aiur_fn_155(
     let __v_7: G = __loaded[5];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_155] = [__v_0];
-        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_159] = [__v_0];
+        record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -17881,46 +17981,46 @@ fn aiur_fn_155(
         let __v_11: G = __loaded[3];
         let __v_12: G = __loaded[4];
         let __v_13: G = __loaded[5];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__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[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_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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_155] = [__v_14];
-        record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_159] = [__v_14];
+        record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_156: usize = 3;
-const IN_156: usize = 3;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
+const INPUT_SIZE_160: usize = 3;
+const IN_160: usize = 3;
+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_156], 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];
     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 __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 __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_156] = [__v_3];
-    record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_160] = [__v_3];
+    record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_157: usize = 2;
-const IN_157: usize = 2;
-const OUT_157: usize = 1;
-fn aiur_fn_157(
-  inp: [G; IN_157],
+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_157], 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];
@@ -17977,20 +18077,20 @@ fn aiur_fn_157(
         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_157] = [__v_51];
-        record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_161] = [__v_51];
+        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_49: G = G::from_u64(0);
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_50: G = __r_arr[0];
         let __v_51: G = (__v_1 + __v_50);
-        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_48, __v_51]; 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_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 __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_157] = [__v_53];
-        record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_161] = [__v_53];
+        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -18000,15 +18100,15 @@ fn aiur_fn_157(
   })
 }
 
-const INPUT_SIZE_158: usize = 3;
-const IN_158: usize = 3;
-const OUT_158: usize = 1;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+const INPUT_SIZE_162: usize = 3;
+const IN_162: usize = 3;
+const OUT_162: usize = 1;
+fn aiur_fn_162(
+  inp: [G; IN_162],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_158], 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];
@@ -18018,8 +18118,8 @@ fn aiur_fn_158(
         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_158] = [__v_5];
-        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_162] = [__v_5];
+        record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -18031,47 +18131,47 @@ fn aiur_fn_158(
         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_158] = { let __args: [G; IN_158] = [__v_8, __v_1, __v_10]; 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_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 __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_158] = [__v_12];
-        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_162] = [__v_12];
+        record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_159: usize = 3;
-const IN_159: usize = 3;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+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_159], 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 __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_0, __v_1]; 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_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 __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_159] = [__v_3];
-    record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_163] = [__v_3];
+    record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_160: usize = 2;
-const IN_160: usize = 2;
-const OUT_160: usize = 1;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+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_160], 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];
@@ -18128,8 +18228,8 @@ fn aiur_fn_160(
         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_160] = [__v_51];
-        record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_164] = [__v_51];
+        record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -18137,20 +18237,20 @@ fn aiur_fn_160(
           1u64 => {
             match __v_4.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_30]; 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_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 __v_49: G = __r_arr[0];
                 let __v_50: G = G::from_u64(0);
-                let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_49, __v_1, __v_50]; 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_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 __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_160] = { let __args: [G; IN_160] = [__v_48, __v_54]; 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_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 __v_55: G = __r_arr[0];
-                let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_51, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 __v_56: G = __r_arr[0];
-                let __ret: [G; OUT_160] = [__v_56];
-                record.function_queries[160].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);
               },
             }
@@ -18158,19 +18258,19 @@ fn aiur_fn_160(
           0u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_48, __v_50]; 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_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 __v_51: G = __r_arr[0];
-            let __ret: [G; OUT_160] = [__v_51];
-            record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_164] = [__v_51];
+            record.function_queries[164].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_160] = { let __args: [G; IN_160] = [__v_48, __v_50]; 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_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 __v_51: G = __r_arr[0];
-            let __ret: [G; OUT_160] = [__v_51];
-            record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_164] = [__v_51];
+            record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -18185,15 +18285,15 @@ fn aiur_fn_160(
   })
 }
 
-const INPUT_SIZE_161: usize = 1;
-const IN_161: usize = 1;
-const OUT_161: usize = 1;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_165: usize = 1;
+const IN_165: usize = 1;
+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_161], ExecError> {
+) -> Result<[G; OUT_165], 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 };
@@ -18247,23 +18347,23 @@ fn aiur_fn_161(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_161] = [__v_48];
-        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_165] = [__v_48];
+        record.function_queries[165].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_161] = [__v_48];
-            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_165] = [__v_48];
+            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_47]; 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_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 __v_48: G = __r_arr[0];
-            let __ret: [G; OUT_161] = [__v_48];
-            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_165] = [__v_48];
+            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -18275,15 +18375,15 @@ fn aiur_fn_161(
   })
 }
 
-const INPUT_SIZE_162: usize = 19;
-const IN_162: usize = 19;
-const OUT_162: usize = 18;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+const INPUT_SIZE_166: usize = 19;
+const IN_166: usize = 19;
+const OUT_166: usize = 18;
+fn aiur_fn_166(
+  inp: [G; IN_166],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_162], 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];
@@ -18306,9 +18406,9 @@ fn aiur_fn_162(
     let __v_18: G = inp[18];
     match __v_0.as_canonical_u64() {
       11u64 => {
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_18, __v_19]; 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_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 __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];
@@ -18335,7 +18435,7 @@ fn aiur_fn_162(
             let __v_39: G = __loaded[15];
             let __v_40: G = __loaded[16];
             let __v_41: G = __loaded[17];
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__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[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_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 __v_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
             let __v_44: G = __r_arr[2];
@@ -18354,8 +18454,8 @@ fn aiur_fn_162(
             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_162] = [__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[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -18364,23 +18464,23 @@ fn aiur_fn_162(
         }
       },
       _ => {
-        let __ret: [G; OUT_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_163: usize = 20;
-const IN_163: usize = 20;
-const OUT_163: usize = 18;
-fn aiur_fn_163(
-  inp: [G; IN_163],
+const INPUT_SIZE_167: usize = 20;
+const IN_167: usize = 20;
+const OUT_167: usize = 18;
+fn aiur_fn_167(
+  inp: [G; IN_167],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_163], 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];
@@ -18404,7 +18504,7 @@ fn aiur_fn_163(
     let __v_19: G = inp[19];
     match __v_18.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_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[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_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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -18423,12 +18523,12 @@ fn aiur_fn_163(
         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_163] = [__v_20, __v_21, __v_22, __v_23, __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[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_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[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_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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -18470,7 +18570,7 @@ fn aiur_fn_163(
             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_163] = { let __args: [G; IN_163] = [__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[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_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 __v_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
             let __v_60: G = __r_arr[2];
@@ -18489,13 +18589,13 @@ fn aiur_fn_163(
             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_163] = [__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[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_163] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -18504,15 +18604,15 @@ fn aiur_fn_163(
   })
 }
 
-const INPUT_SIZE_164: usize = 19;
-const IN_164: usize = 19;
-const OUT_164: usize = 18;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+const INPUT_SIZE_168: usize = 19;
+const IN_168: usize = 19;
+const OUT_168: usize = 18;
+fn aiur_fn_168(
+  inp: [G; IN_168],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_164], ExecError> {
+) -> Result<[G; OUT_168], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18533,7 +18633,7 @@ fn aiur_fn_164(
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
     let __v_18: G = inp[18];
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[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_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 __v_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
     let __v_21: G = __r_arr[2];
@@ -18573,7 +18673,7 @@ fn aiur_fn_164(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__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[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_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 __v_55: G = __r_arr[0];
         let __v_56: G = __r_arr[1];
         let __v_57: G = __r_arr[2];
@@ -18592,12 +18692,12 @@ fn aiur_fn_164(
         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_164] = [__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[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[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_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 __v_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -18616,23 +18716,23 @@ fn aiur_fn_164(
         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_164] = [__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[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_165: usize = 21;
-const IN_165: usize = 21;
-const OUT_165: usize = 1;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+const INPUT_SIZE_169: usize = 21;
+const IN_169: usize = 21;
+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_165], 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];
@@ -18655,7 +18755,7 @@ fn aiur_fn_165(
     let __v_18: G = inp[18];
     let __v_19: G = inp[19];
     let __v_20: G = inp[20];
-    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, __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[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_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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -18695,7 +18795,7 @@ fn aiur_fn_165(
         let __v_54: G = __loaded[15];
         let __v_55: G = __loaded[16];
         let __v_56: G = __loaded[17];
-        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__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[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_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 __v_57: G = __r_arr[0];
         let __v_58: G = __r_arr[1];
         let __v_59: G = __r_arr[2];
@@ -18716,12 +18816,12 @@ fn aiur_fn_165(
         let __v_74: G = __r_arr[17];
         match __v_57.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_75: G = __r_arr[0];
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_19, __v_75]; 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_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 __v_76: G = __r_arr[0];
-            let __ret: [G; OUT_165] = [__v_76];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_169] = [__v_76];
+            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -18758,8 +18858,8 @@ fn aiur_fn_165(
             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_165] = [__v_107];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_169] = [__v_107];
+            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -18798,23 +18898,23 @@ fn aiur_fn_165(
         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_165] = [__v_71];
-        record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_169] = [__v_71];
+        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_166: usize = 48;
-const IN_166: usize = 48;
-const OUT_166: usize = 2;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_170: usize = 48;
+const IN_170: usize = 48;
+const OUT_170: usize = 2;
+fn aiur_fn_170(
+  inp: [G; IN_170],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_166], 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];
@@ -18885,20 +18985,20 @@ fn aiur_fn_166(
         let __v_63: G = __loaded[15];
         let __v_64: G = __loaded[16];
         let __v_65: G = __loaded[17];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_66: G = __r_arr[0];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_67: G = __r_arr[0];
         let __v_68: G = (__v_66 + __v_67);
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_69: G = __r_arr[0];
         let __v_70: G = (__v_68 + __v_69);
-        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_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 __v_71: G = __r_arr[0];
         let __v_72: G = (__v_70 + __v_71);
-        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__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[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_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 __v_73: G = __r_arr[0];
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_73]; 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_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 __v_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -18953,7 +19053,7 @@ fn aiur_fn_166(
               6u64 => {
                 match __v_75.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_83]; 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_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 __v_122: G = __r_arr[0];
                     let __v_123: G = __r_arr[1];
                     let __v_124: G = __r_arr[2];
@@ -19006,14 +19106,14 @@ fn aiur_fn_166(
                       _ => {
                         match __v_122.as_canonical_u64() {
                           8u64 => {
-                            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_83, __v_47]; 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_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 __v_170: G = __r_arr[0];
-                            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_171: G = __r_arr[0];
-                            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_123, __v_170, __v_171]; 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_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 __v_172: G = __r_arr[0];
-                            let __ret: [G; OUT_166] = [__v_172, __v_83];
-                            record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_170] = [__v_172, __v_83];
+                            record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -19036,37 +19136,37 @@ fn aiur_fn_166(
   })
 }
 
-const INPUT_SIZE_167: usize = 3;
-const IN_167: usize = 3;
-const OUT_167: usize = 1;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+const INPUT_SIZE_171: usize = 3;
+const IN_171: usize = 3;
+const OUT_171: usize = 1;
+fn aiur_fn_171(
+  inp: [G; IN_171],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_167], 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];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_1, __v_2, __v_3]; 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_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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_167] = [__v_4];
-    record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_171] = [__v_4];
+    record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_168: usize = 4;
-const IN_168: usize = 4;
-const OUT_168: usize = 1;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+const INPUT_SIZE_172: usize = 4;
+const IN_172: usize = 4;
+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_168], ExecError> {
+) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19125,12 +19225,12 @@ fn aiur_fn_168(
         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_168] = [__v_53];
-        record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_172] = [__v_53];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __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));
@@ -19140,13 +19240,13 @@ fn aiur_fn_168(
               1u64 => {
                 match __v_6.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_32]; 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_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 __v_54: G = __r_arr[0];
                     let __v_55: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_54, __v_1, __v_55]; 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_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 __v_56: G = __r_arr[0];
-                    let __ret: [G; OUT_168] = [__v_56];
-                    record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_172] = [__v_56];
+                    record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -19155,8 +19255,8 @@ fn aiur_fn_168(
                 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_168] = [__v_56];
-                record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_172] = [__v_56];
+                record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -19165,10 +19265,10 @@ fn aiur_fn_168(
             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_168] = { let __args: [G; IN_168] = [__v_50, __v_54, __v_2, __v_56]; 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_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 __v_57: G = __r_arr[0];
-            let __ret: [G; OUT_168] = [__v_57];
-            record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_172] = [__v_57];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -19183,15 +19283,15 @@ fn aiur_fn_168(
   })
 }
 
-const INPUT_SIZE_169: usize = 57;
-const IN_169: usize = 57;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+const INPUT_SIZE_173: usize = 57;
+const IN_173: usize = 57;
+const OUT_173: usize = 1;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_169], 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];
@@ -19254,34 +19354,34 @@ fn aiur_fn_169(
       1u64 => {
         match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_27]; 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_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 __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_50, __v_52]; 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_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 __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_158] = { let __args: [G; IN_158] = [__v_57, __v_59, __v_60]; 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_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 __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_170] = { let __args: [G; IN_170] = [__v_27, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; 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_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 __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_169] = [__v_67];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_173] = [__v_67];
+            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_50]; 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_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 __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_159] = { let __args: [G; IN_159] = [__v_50, __v_51, __v_58]; 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_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 __v_59: G = __r_arr[0];
             let __v_60: G = G::from_u64(3);
             let __v_61: G = G::from_u64(0);
@@ -19290,8 +19390,8 @@ fn aiur_fn_169(
             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_169] = [__v_66];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_173] = [__v_66];
+            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -19302,7 +19402,7 @@ fn aiur_fn_169(
 }
  };
             let __v_58: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_59: G = __r_arr[0];
             let __v_60: G = __r_arr[1];
             let __v_61: G = G::from_u64(3);
@@ -19312,8 +19412,8 @@ fn aiur_fn_169(
             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_169] = [__v_67];
-            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_173] = [__v_67];
+            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -19331,8 +19431,8 @@ fn aiur_fn_169(
         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_169] = [__v_65];
-        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_173] = [__v_65];
+        record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19342,15 +19442,15 @@ fn aiur_fn_169(
   })
 }
 
-const INPUT_SIZE_170: usize = 7;
-const IN_170: usize = 7;
-const OUT_170: usize = 1;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+const INPUT_SIZE_174: usize = 7;
+const IN_174: usize = 7;
+const OUT_174: usize = 1;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_170], 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];
@@ -19401,8 +19501,8 @@ fn aiur_fn_170(
         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_170] = [__v_45];
-        record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_174] = [__v_45];
+        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -19410,11 +19510,11 @@ fn aiur_fn_170(
         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_170] = { let __args: [G; IN_170] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __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_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 __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_170] = [__v_48];
-        record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_174] = [__v_48];
+        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19424,15 +19524,15 @@ fn aiur_fn_170(
   })
 }
 
-const INPUT_SIZE_171: usize = 13;
-const IN_171: usize = 13;
-const OUT_171: usize = 1;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+const INPUT_SIZE_175: usize = 13;
+const IN_175: usize = 13;
+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_171], 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];
@@ -19500,21 +19600,21 @@ fn aiur_fn_171(
         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_171] = [__v_62];
-        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_175] = [__v_62];
+        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __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_171] = { let __args: [G; IN_171] = [__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[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_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 __v_63: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_64: G = __r_arr[0];
-        let __ret: [G; OUT_171] = [__v_64];
-        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_175] = [__v_64];
+        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19524,15 +19624,15 @@ fn aiur_fn_171(
   })
 }
 
-const INPUT_SIZE_172: usize = 1;
-const IN_172: usize = 1;
-const OUT_172: usize = 2;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+const INPUT_SIZE_176: usize = 1;
+const IN_176: usize = 1;
+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_172], ExecError> {
+) -> Result<[G; OUT_176], 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 };
@@ -19541,8 +19641,8 @@ fn aiur_fn_172(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_172] = [__v_2, __v_3];
-        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_176] = [__v_2, __v_3];
+        record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -19552,15 +19652,15 @@ fn aiur_fn_172(
   })
 }
 
-const INPUT_SIZE_173: usize = 7;
-const IN_173: usize = 7;
-const OUT_173: usize = 1;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+const INPUT_SIZE_177: usize = 7;
+const IN_177: usize = 7;
+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_173], 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];
@@ -19569,14 +19669,14 @@ fn aiur_fn_173(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2, __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 __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 __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_135] = { let __args: [G; IN_135] = [__v_0, __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 __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 __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     let __v_15: G = __r_arr[2];
@@ -19587,23 +19687,23 @@ fn aiur_fn_173(
     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_174] = { let __args: [G; IN_174] = [__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[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_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 __v_23: G = __r_arr[0];
-    let __ret: [G; OUT_173] = [__v_23];
-    record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_177] = [__v_23];
+    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_174: usize = 9;
-const IN_174: usize = 9;
-const OUT_174: usize = 1;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+const INPUT_SIZE_178: usize = 9;
+const IN_178: usize = 9;
+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_174], 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];
@@ -19623,8 +19723,8 @@ fn aiur_fn_174(
         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_174] = [__v_14];
-        record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_178] = [__v_14];
+        record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -19677,14 +19777,14 @@ fn aiur_fn_174(
         let __v_57: G = __loaded[45];
         let __v_58: G = __loaded[46];
         let __v_59: G = __loaded[47];
-        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 __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 __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_141] = { let __args: [G; IN_141] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_62: G = __r_arr[0];
                 let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_62.as_canonical_u64() {
   0u64 => {
@@ -19692,7 +19792,7 @@ fn aiur_fn_174(
     break '__mc_0 [__v_63];
   },
   _ => {
-    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_62, __v_8]; 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_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 __v_63: G = __r_arr[0];
     break '__mc_0 [__v_63];
   },
@@ -19701,10 +19801,10 @@ fn aiur_fn_174(
                 let __v_63: G = __mc_out___mc_0[0];
                 match __v_63.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_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 __v_64: G = __r_arr[0];
-                    let __ret: [G; OUT_174] = [__v_64];
-                    record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_178] = [__v_64];
+                    record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -19720,28 +19820,28 @@ fn aiur_fn_174(
 }
  };
                     let __v_64: G = __mc_out___mc_1[0];
-                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_13]; 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 __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 __v_65: G = __r_arr[0];
-                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_60, __v_3]; 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_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 __v_66: G = __r_arr[0];
-                    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_60, __v_5]; 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_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 __v_67: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; 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_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 __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_156] = { let __args: [G; IN_156] = [__v_13, __v_66, __v_70]; 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_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 __v_71: G = __r_arr[0];
                     let __v_72: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__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[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_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 __v_73: G = __r_arr[0];
                     let __v_74: G = (__v_7 + __v_65);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_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 __v_75: G = __r_arr[0];
-                    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 __v_76: G = __r_arr[0];
-                    let __ret: [G; OUT_174] = [__v_76];
-                    record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_178] = [__v_76];
+                    record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -19750,35 +19850,35 @@ fn aiur_fn_174(
                 }
               },
               6u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_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 __v_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_62];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               4u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_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 __v_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_62];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               5u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_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 __v_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_62];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               7u64 => {
-                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_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 __v_62: G = __r_arr[0];
-                let __ret: [G; OUT_174] = [__v_62];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_62];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; 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_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 __v_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
                 let __v_64: G = G::from_u64(0);
@@ -19786,7 +19886,7 @@ fn aiur_fn_174(
                 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_127] = { let __args: [G; IN_127] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_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 __v_69: G = __r_arr[0];
                 let __v_70: G = G::from_u64(0);
                 let __v_71: G = G::from_u64(0);
@@ -19794,15 +19894,15 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[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_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 __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_174] = [__v_77];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_77];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               2u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; 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_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 __v_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
                 let __v_64: G = G::from_u64(1);
@@ -19814,15 +19914,15 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[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_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 __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_174] = [__v_74];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_74];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               3u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; 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_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 __v_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
                 let __v_64: G = G::from_u64(1);
@@ -19834,18 +19934,18 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[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_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 __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_174] = [__v_74];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_74];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_58, __v_3]; 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_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 __v_62: G = __r_arr[0];
                 let __v_63: G = __r_arr[1];
-                let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[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_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 __v_64: G = __r_arr[0];
                 let __v_65: G = __r_arr[1];
                 let __v_66: G = G::from_u64(0);
@@ -19858,11 +19958,11 @@ fn aiur_fn_174(
                 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_174] = { let __args: [G; IN_174] = [__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[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_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 __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_174] = [__v_77];
-                record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_178] = [__v_77];
+                record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -19879,15 +19979,15 @@ fn aiur_fn_174(
   })
 }
 
-const INPUT_SIZE_175: usize = 10;
-const IN_175: usize = 10;
-const OUT_175: usize = 2;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+const INPUT_SIZE_179: usize = 10;
+const IN_179: usize = 10;
+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_175], 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];
@@ -19900,7 +20000,7 @@ fn aiur_fn_175(
     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_773] = { let __args: [G; IN_773] = [__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[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_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 __v_11: G = __r_arr[0];
     match __v_11.as_canonical_u64() {
       1u64 => {
@@ -19910,16 +20010,16 @@ fn aiur_fn_175(
         let __v_14: G = __loaded[2];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_175] = [__v_2, __v_3];
-            record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_179] = [__v_2, __v_3];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[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_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 __v_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __ret: [G; OUT_175] = [__v_15, __v_16];
-            record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_179] = [__v_15, __v_16];
+            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -19990,16 +20090,16 @@ fn aiur_fn_175(
             let __v_55: G = __loaded[2];
             match __v_53.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_175] = [__v_2, __v_3];
-                record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_179] = [__v_2, __v_3];
+                record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[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_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 __v_56: G = __r_arr[0];
                 let __v_57: G = __r_arr[1];
-                let __ret: [G; OUT_175] = [__v_56, __v_57];
-                record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_179] = [__v_56, __v_57];
+                record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -20011,14 +20111,14 @@ fn aiur_fn_175(
             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_784] = { let __args: [G; IN_784] = [__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[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_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 __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_123] = { let __args: [G; IN_123] = [__v_0]; 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_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 __v_62: G = __r_arr[0];
             let __v_63: G = __r_arr[1];
             let __v_64: G = __r_arr[2];
@@ -20072,7 +20172,7 @@ fn aiur_fn_175(
             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_129] = { let __args: [G; IN_129] = [__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[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_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 __v_113: G = __r_arr[0];
                 let __v_114: G = G::from_u64(0);
                 let __v_115: G = G::from_u64(0);
@@ -20107,16 +20207,16 @@ fn aiur_fn_175(
                 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_126] = { let __args: [G; IN_126] = [__v_113, __v_146]; 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_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 __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_772] = { let __args: [G; IN_772] = [__v_108, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 __v_151: G = __r_arr[0];
-                    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_151, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 __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];
@@ -20124,16 +20224,16 @@ fn aiur_fn_175(
                     let __v_155: G = __loaded[2];
                     match __v_153.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_175] = [__v_54, __v_112];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_179] = [__v_54, __v_112];
+                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[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_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 __v_156: G = __r_arr[0];
                         let __v_157: G = __r_arr[1];
-                        let __ret: [G; OUT_175] = [__v_156, __v_157];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_179] = [__v_156, __v_157];
+                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -20147,9 +20247,9 @@ fn aiur_fn_175(
                     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_772] = { let __args: [G; IN_772] = [__v_108, __v_152]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 __v_153: G = __r_arr[0];
-                    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_153, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 __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];
@@ -20157,16 +20257,16 @@ fn aiur_fn_175(
                     let __v_157: G = __loaded[2];
                     match __v_155.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_175] = [__v_54, __v_112];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_179] = [__v_54, __v_112];
+                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__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[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_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 __v_158: G = __r_arr[0];
                         let __v_159: G = __r_arr[1];
-                        let __ret: [G; OUT_175] = [__v_158, __v_159];
-                        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_179] = [__v_158, __v_159];
+                        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -20187,15 +20287,15 @@ fn aiur_fn_175(
   })
 }
 
-const INPUT_SIZE_176: usize = 1;
-const IN_176: usize = 1;
-const OUT_176: usize = 1;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+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_176], ExecError> {
+) -> 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);
@@ -20209,15 +20309,15 @@ fn aiur_fn_176(
     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_175] = { let __args: [G; IN_175] = [__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[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_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_144] = { let __args: [G; IN_144] = [__v_13, __v_12, __v_14]; 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_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_137] = { let __args: [G; IN_137] = [__v_15, __v_16]; 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_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];
@@ -20226,11 +20326,11 @@ fn aiur_fn_176(
     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_146] = { let __args: [G; IN_146] = [__v_13, __v_12, __v_24, __v_25]; 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_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_152] = { let __args: [G; IN_152] = [__v_13, __v_26]; 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_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_154] = { let __args: [G; IN_154] = [__v_12, __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 __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];
@@ -20239,25 +20339,25 @@ fn aiur_fn_176(
     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_173] = { let __args: [G; IN_173] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; 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_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_122] = { let __args: [G; IN_122] = [__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 __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_176] = [__v_37];
-    record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_180] = [__v_37];
+    record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_177: usize = 5;
-const IN_177: usize = 5;
-const OUT_177: usize = 1;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+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_177], 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];
@@ -20270,36 +20370,36 @@ fn aiur_fn_177(
         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_177] = [__v_8];
-        record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_181] = { let __args: [G; IN_181] = [__v_0, __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 __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_177] = { let __args: [G; IN_177] = [__v_9, __v_1, __v_2, __v_3, __v_4]; 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_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_177] = [__v_11];
-        record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_181] = [__v_11];
+        record.function_queries[181].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],
+const INPUT_SIZE_182: usize = 1;
+const IN_182: usize = 1;
+const OUT_182: usize = 1;
+fn aiur_fn_182(
+  inp: [G; IN_182],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_178], ExecError> {
+) -> Result<[G; OUT_182], 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 };
@@ -20356,32 +20456,32 @@ fn aiur_fn_178(
         match __v_1.as_canonical_u64() {
           6u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_182] = [__v_49];
+            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_182] = [__v_49];
+            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_182] = [__v_49];
+            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_182] = [__v_49];
+            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_178] = [__v_49];
-            record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_182] = [__v_49];
+            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -20390,15 +20490,15 @@ fn aiur_fn_178(
   })
 }
 
-const INPUT_SIZE_179: usize = 4;
-const IN_179: usize = 4;
-const OUT_179: usize = 2;
-fn aiur_fn_179(
-  inp: [G; IN_179],
+const INPUT_SIZE_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_179], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20444,8 +20544,8 @@ fn aiur_fn_179(
         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_179] = [__v_7, __v_40];
-        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_183] = [__v_7, __v_40];
+        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -20463,22 +20563,22 @@ fn aiur_fn_179(
               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_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 __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_179] = [__v_17, __v_5];
-                    record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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_179] = { let __args: [G; IN_179] = [__v_0, __v_6, __v_9, __v_12]; 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_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_179] = [__v_17, __v_18];
-                    record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_183] = [__v_17, __v_18];
+                    record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -20500,15 +20600,15 @@ fn aiur_fn_179(
   })
 }
 
-const INPUT_SIZE_180: usize = 3;
-const IN_180: usize = 3;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+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_180], 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];
@@ -20552,8 +20652,8 @@ fn aiur_fn_180(
         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_180] = [__v_38];
-        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_184] = [__v_38];
+        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -20566,15 +20666,15 @@ fn aiur_fn_180(
             let __v_9: G = (__v_7 - __v_0);
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_180] = [__v_4];
-                record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_180] = { let __args: [G; IN_180] = [__v_0, __v_5, __v_8]; 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 __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_180] = [__v_10];
-                record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_184] = [__v_10];
+                record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -20591,34 +20691,34 @@ fn aiur_fn_180(
   })
 }
 
-const INPUT_SIZE_181: usize = 4;
-const IN_181: usize = 4;
-const OUT_181: usize = 1;
-fn aiur_fn_181(
-  inp: [G; IN_181],
+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_181], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3]; 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_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_181] = [__v_5];
-        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_3]; 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 __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_181] = [__v_6];
-        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_185] = [__v_6];
+        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -20628,15 +20728,15 @@ fn aiur_fn_181(
   })
 }
 
-const INPUT_SIZE_182: usize = 10;
-const IN_182: usize = 10;
-const OUT_182: usize = 6;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+const INPUT_SIZE_186: usize = 10;
+const IN_186: usize = 10;
+const OUT_186: usize = 6;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_182], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20654,8 +20754,8 @@ fn aiur_fn_182(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_182] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -20671,39 +20771,39 @@ fn aiur_fn_182(
             let __v_18: G = __loaded[2];
             match __v_16.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_14]; 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_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 __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_784] = { let __args: [G; IN_784] = [__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[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_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 __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_182] = { let __args: [G; IN_182] = [__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[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_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 __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_182] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-                    record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__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[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_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 __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_182] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-                    record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -20725,15 +20825,15 @@ fn aiur_fn_182(
   })
 }
 
-const INPUT_SIZE_183: usize = 3;
-const IN_183: usize = 3;
-const OUT_183: usize = 6;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_187: usize = 3;
+const IN_187: usize = 3;
+const OUT_187: usize = 6;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_183], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20741,7 +20841,7 @@ fn aiur_fn_183(
     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_182] = { let __args: [G; IN_182] = [__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[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_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 __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -20749,28 +20849,28 @@ fn aiur_fn_183(
     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_182] = { let __args: [G; IN_182] = [__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[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_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 __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_183] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-    record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_184: usize = 7;
-const IN_184: usize = 7;
-const OUT_184: usize = 6;
-fn aiur_fn_184(
-  inp: [G; IN_184],
+const INPUT_SIZE_188: usize = 7;
+const IN_188: usize = 7;
+const OUT_188: usize = 6;
+fn aiur_fn_188(
+  inp: [G; IN_188],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], 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];
@@ -20786,27 +20886,27 @@ fn aiur_fn_184(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_184] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__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[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_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 __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_184] = { let __args: [G; IN_184] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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 __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_184] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -20816,15 +20916,15 @@ fn aiur_fn_184(
   })
 }
 
-const INPUT_SIZE_185: usize = 9;
-const IN_185: usize = 9;
-const OUT_185: usize = 1;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_189: usize = 9;
+const IN_189: usize = 9;
+const OUT_189: usize = 1;
+fn aiur_fn_189(
+  inp: [G; IN_189],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_185], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20841,36 +20941,36 @@ fn aiur_fn_185(
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 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_185] = [__v_12];
-        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_189] = [__v_12];
+        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__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[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_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 __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_185] = { let __args: [G; IN_185] = [__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[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 __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 __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_185] = [__v_15];
-        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_189] = [__v_15];
+        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_186: usize = 3;
-const IN_186: usize = 3;
-const OUT_186: usize = 1;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_190: usize = 3;
+const IN_190: usize = 3;
+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_186], ExecError> {
+) -> Result<[G; OUT_190], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20884,8 +20984,8 @@ fn aiur_fn_186(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_186] = [__v_8];
-        record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_190] = [__v_8];
+        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -20950,9 +21050,9 @@ fn aiur_fn_186(
                   6u64 => {
                     match __v_7.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_2]; 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_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 __v_57: G = __r_arr[0];
-                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_15]; 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_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 __v_58: G = __r_arr[0];
                         let __v_59: G = __r_arr[1];
                         let __v_60: G = __r_arr[2];
@@ -21005,33 +21105,33 @@ fn aiur_fn_186(
                           _ => {
                             match __v_58.as_canonical_u64() {
                               8u64 => {
-                                let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_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 __v_106: G = __r_arr[0];
-                                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_59, __v_106]; 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_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 __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_14] = { let __args: [G; IN_14] = [__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[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_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 __v_111: G = __r_arr[0];
-                                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_59, __v_111]; 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_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 __v_112: G = __r_arr[0];
                                 let __v_113: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__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[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_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 __v_114: G = __r_arr[0];
-                                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_56, __v_2]; 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_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 __v_115: G = __r_arr[0];
-                                let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_114, __v_115]; 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_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 __v_116: G = __r_arr[0];
-                                let __ret: [G; OUT_186] = [__v_116];
-                                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_190] = [__v_116];
+                                record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_56, __v_2]; 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_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 __v_106: G = __r_arr[0];
-                                let __ret: [G; OUT_186] = [__v_106];
-                                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_190] = [__v_106];
+                                record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -21041,10 +21141,10 @@ fn aiur_fn_186(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_56, __v_2]; 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_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 __v_57: G = __r_arr[0];
-                    let __ret: [G; OUT_186] = [__v_57];
-                    record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_190] = [__v_57];
+                    record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -21063,36 +21163,36 @@ fn aiur_fn_186(
   })
 }
 
-const INPUT_SIZE_187: usize = 2;
-const IN_187: usize = 2;
-const OUT_187: usize = 1;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+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_187], 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];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_0, __v_1, __v_2]; 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_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 __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_187] = [__v_3];
-    record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_191] = [__v_3];
+    record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_188: usize = 3;
-const IN_188: usize = 3;
-const OUT_188: usize = 1;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+const INPUT_SIZE_192: usize = 3;
+const IN_192: usize = 3;
+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_188], 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];
@@ -21148,8 +21248,8 @@ fn aiur_fn_188(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_50: G = G::from_u64(0);
-        let __ret: [G; OUT_188] = [__v_50];
-        record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_192] = [__v_50];
+        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21160,18 +21260,18 @@ fn aiur_fn_188(
               1u64 => {
                 match __v_5.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_31]; 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_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 __v_51: G = __r_arr[0];
-                    let __ret: [G; OUT_188] = [__v_51];
-                    record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_192] = [__v_51];
+                    record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_51: G = G::from_u64(0);
-                let __ret: [G; OUT_188] = [__v_51];
-                record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_192] = [__v_51];
+                record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -21179,10 +21279,10 @@ fn aiur_fn_188(
           _ => {
             let __v_51: G = G::from_u64(1);
             let __v_52: G = (__v_2 + __v_51);
-            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_49, __v_1, __v_52]; 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_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 __v_53: G = __r_arr[0];
-            let __ret: [G; OUT_188] = [__v_53];
-            record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_192] = [__v_53];
+            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -21194,15 +21294,15 @@ fn aiur_fn_188(
   })
 }
 
-const INPUT_SIZE_189: usize = 12;
-const IN_189: usize = 12;
-const OUT_189: usize = 1;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+const INPUT_SIZE_193: usize = 12;
+const IN_193: usize = 12;
+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_189], 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];
@@ -21222,37 +21322,37 @@ fn aiur_fn_189(
         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_189] = [__v_15];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_193] = [__v_15];
+        record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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[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_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 __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_189] = { let __args: [G; IN_189] = [__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[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_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 __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_189] = [__v_19];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_193] = [__v_19];
+        record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_190: usize = 10;
-const IN_190: usize = 10;
-const OUT_190: usize = 1;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+const INPUT_SIZE_194: usize = 10;
+const IN_194: usize = 10;
+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_190], 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];
@@ -21285,25 +21385,25 @@ fn aiur_fn_190(
     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_69] = { let __args: [G; IN_69] = [__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[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_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 __v_31: G = __r_arr[0];
-    let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_32: G = __r_arr[0];
-    let __ret: [G; OUT_190] = [__v_32];
-    record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_194] = [__v_32];
+    record.function_queries[194].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 = 2;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+const INPUT_SIZE_195: usize = 1;
+const IN_195: usize = 1;
+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_191], ExecError> {
+) -> Result<[G; OUT_195], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
@@ -21317,27 +21417,27 @@ fn aiur_fn_191(
     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_175] = { let __args: [G; IN_175] = [__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[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_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 __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_12, __v_13]; 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_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 __v_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __ret: [G; OUT_191] = [__v_14, __v_15];
-    record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_195] = [__v_14, __v_15];
+    record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 1;
-const IN_192: usize = 1;
-const OUT_192: usize = 2;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+const INPUT_SIZE_196: usize = 1;
+const IN_196: usize = 1;
+const OUT_196: usize = 2;
+fn aiur_fn_196(
+  inp: [G; IN_196],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_196], 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 };
@@ -21346,11 +21446,11 @@ fn aiur_fn_192(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __ret: [G; OUT_192] = [__v_4, __v_5];
-        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_196] = [__v_4, __v_5];
+        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -21362,14 +21462,14 @@ fn aiur_fn_192(
         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_175] = { let __args: [G; IN_175] = [__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[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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_12, __v_13]; 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_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 __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __ret: [G; OUT_192] = [__v_14, __v_15];
-        record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_196] = [__v_14, __v_15];
+        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -21379,24 +21479,24 @@ fn aiur_fn_192(
   })
 }
 
-const INPUT_SIZE_193: usize = 2;
-const IN_193: usize = 2;
-const OUT_193: usize = 2;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_197: usize = 2;
+const IN_197: usize = 2;
+const OUT_197: usize = 2;
+fn aiur_fn_197(
+  inp: [G; IN_197],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], 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];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_0, __v_2]; 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_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 __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_137] = { let __args: [G; IN_137] = [__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 __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 __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -21405,11 +21505,11 @@ fn aiur_fn_193(
     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_146] = { let __args: [G; IN_146] = [__v_1, __v_0, __v_12, __v_13]; 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_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 __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __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 __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 __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __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 __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_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
     let __v_18: G = __r_arr[2];
@@ -21418,20 +21518,20 @@ fn aiur_fn_193(
     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_173] = { let __args: [G; IN_173] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; 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_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 __v_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__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 __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 __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_15]; 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 __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 __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_186] = { let __args: [G; IN_186] = [__v_1, __v_0, __v_12]; 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_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 __v_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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 __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 __v_33: G = __r_arr[0];
     let __v_34: G = __r_arr[1];
     let __v_35: G = __r_arr[2];
@@ -21472,32 +21572,32 @@ fn aiur_fn_193(
     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_185] = { let __args: [G; IN_185] = [__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[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 __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 __v_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
     let __v_74: G = __r_arr[0];
     let __v_75: G = __r_arr[1];
-    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_25, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_77: G = __r_arr[0];
-    let __ret: [G; OUT_193] = [__v_76, __v_77];
-    record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_197] = [__v_76, __v_77];
+    record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_194: usize = 0;
-const IN_194: usize = 0;
-const OUT_194: usize = 2;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+const INPUT_SIZE_198: usize = 0;
+const IN_198: usize = 0;
+const OUT_198: usize = 2;
+fn aiur_fn_198(
+  inp: [G; IN_198],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
     let __v_0: G = __r_arr[0];
     let __v_1: G = G::from_u64(1);
     let __v_2: G = G::from_u64(0);
@@ -21510,232 +21610,232 @@ fn aiur_fn_194(
     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_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_11, __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 __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 __v_13: G = __r_arr[0];
-    let __ret: [G; OUT_194] = [__v_13, __v_0];
-    record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_198] = [__v_13, __v_0];
+    record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_195: usize = 0;
-const IN_195: usize = 0;
-const OUT_195: usize = 1;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+const INPUT_SIZE_199: usize = 0;
+const IN_199: usize = 0;
+const OUT_199: usize = 1;
+fn aiur_fn_199(
+  inp: [G; IN_199],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(0);
-    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
+    let __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_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
+    let __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_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+    let __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_7: G = __r_arr[0];
     let __v_8: 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_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_9: G = __r_arr[0];
     let __v_10: 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_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_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_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_13: G = __r_arr[0];
     let __v_14: 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_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_15: G = __r_arr[0];
     let __v_16: 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_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_17: G = __r_arr[0];
     let __v_18: 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_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_19: G = __r_arr[0];
     let __v_20: 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_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_21: G = __r_arr[0];
     let __v_22: 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_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_23: G = __r_arr[0];
     let __v_24: 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_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_25: G = __r_arr[0];
     let __v_26: 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_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_27: G = __r_arr[0];
     let __v_28: 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_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_29: G = __r_arr[0];
     let __v_30: 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_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_31: G = __r_arr[0];
     let __v_32: 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_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_33: G = __r_arr[0];
     let __v_34: 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_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_35: G = __r_arr[0];
     let __v_36: 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_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_37: G = __r_arr[0];
     let __v_38: 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_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_39: G = __r_arr[0];
     let __v_40: 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_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_41: G = __r_arr[0];
     let __v_42: 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_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_43: G = __r_arr[0];
     let __v_44: 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_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_45: G = __r_arr[0];
     let __v_46: 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_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_47: G = __r_arr[0];
     let __v_48: 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_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_49: G = __r_arr[0];
     let __v_50: 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_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_51: G = __r_arr[0];
     let __v_52: 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_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_53: G = __r_arr[0];
     let __v_54: 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_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_55: G = __r_arr[0];
     let __v_56: 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_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_57: G = __r_arr[0];
     let __v_58: 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_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_59: G = __r_arr[0];
     let __v_60: 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_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_61: G = __r_arr[0];
     let __v_62: 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_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_63: G = __r_arr[0];
     let __v_64: 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_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_65: G = __r_arr[0];
     let __v_66: 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_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_67: G = __r_arr[0];
     let __v_68: 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_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_69: G = __r_arr[0];
     let __v_70: 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_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_71: G = __r_arr[0];
     let __v_72: 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_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_73: G = __r_arr[0];
     let __v_74: 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_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_75: G = __r_arr[0];
     let __v_76: 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_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_77: G = __r_arr[0];
     let __v_78: 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_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_79: G = __r_arr[0];
     let __v_80: 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_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_81: G = __r_arr[0];
     let __v_82: 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_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_83: G = __r_arr[0];
     let __v_84: 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_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_85: G = __r_arr[0];
     let __v_86: 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_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_87: G = __r_arr[0];
     let __v_88: 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_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_89: G = __r_arr[0];
     let __v_90: 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_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_91: G = __r_arr[0];
     let __v_92: 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_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_93: G = __r_arr[0];
     let __v_94: 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_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_95: G = __r_arr[0];
     let __v_96: 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_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_97: G = __r_arr[0];
     let __v_98: 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_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_99: G = __r_arr[0];
     let __v_100: 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_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_101: G = __r_arr[0];
     let __v_102: 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_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_103: G = __r_arr[0];
     let __v_104: 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_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_105: G = __r_arr[0];
     let __v_106: 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_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_107: G = __r_arr[0];
     let __v_108: 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_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_109: G = __r_arr[0];
     let __v_110: 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_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_111: G = __r_arr[0];
     let __v_112: 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_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
     let __v_113: G = __r_arr[0];
     let __v_114: 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_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
     let __v_115: G = __r_arr[0];
     let __v_116: 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_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
     let __v_117: G = __r_arr[0];
     let __v_118: 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_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
     let __v_119: G = __r_arr[0];
     let __v_120: 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_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
     let __v_121: G = __r_arr[0];
     let __v_122: 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_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
     let __v_123: G = __r_arr[0];
     let __v_124: 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_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
     let __v_125: G = __r_arr[0];
     let __v_126: 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_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
     let __v_127: G = __r_arr[0];
     let __v_128: 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_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 __v_129: G = __r_arr[0];
     let __v_130: 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_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 __v_131: G = __r_arr[0];
     let __v_132: 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_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 __v_133: G = __r_arr[0];
     let __v_134: 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_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 __v_135: G = __r_arr[0];
     let __v_136: 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_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 __v_137: G = __r_arr[0];
     let __v_138: G = G::from_u64(1);
     let __v_139: G = G::from_u64(1);
@@ -21809,21 +21909,21 @@ fn aiur_fn_195(
     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_195] = [__v_209];
-    record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_199] = [__v_209];
+    record.function_queries[199].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 = 1;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+const INPUT_SIZE_200: usize = 1;
+const IN_200: usize = 1;
+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_196], ExecError> {
+) -> Result<[G; OUT_200], 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 };
@@ -21833,17 +21933,17 @@ fn aiur_fn_196(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_196] = [__v_4];
-        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_200] = [__v_4];
+        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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_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 __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_196] = [__v_6];
-        record.function_queries[196].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);
       },
       _ => {
@@ -21853,15 +21953,15 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_201: usize = 2;
+const IN_201: usize = 2;
+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_197], 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];
@@ -21870,34 +21970,34 @@ fn aiur_fn_197(
         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_197] = [__v_4];
-        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_201] = [__v_4];
+        record.function_queries[201].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_197] = { let __args: [G; IN_197] = [__v_0, __v_4]; 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_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 __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_197] = [__v_6];
-        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_201] = [__v_6];
+        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_198: usize = 1;
-const IN_198: usize = 1;
-const OUT_198: usize = 2;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+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_198], ExecError> {
+) -> Result<[G; OUT_202], 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 };
@@ -21907,36 +22007,36 @@ fn aiur_fn_198(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; 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_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 __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_6, __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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_198] = [__v_5, __v_7];
-        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_202] = [__v_5, __v_7];
+        record.function_queries[202].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_198] = [__v_0, __v_7];
-        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_202] = [__v_0, __v_7];
+        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_199: usize = 1;
-const IN_199: usize = 1;
-const OUT_199: usize = 1;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_203: usize = 1;
+const IN_203: usize = 1;
+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_199], ExecError> {
+) -> Result<[G; OUT_203], 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 };
@@ -21946,57 +22046,57 @@ fn aiur_fn_199(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_203] = [__v_4];
+        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_203] = [__v_4];
+        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_203] = [__v_4];
+        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; 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_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 __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; 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_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 __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_199] = [__v_6];
-                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_203] = [__v_6];
+                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_6: G = G::from_u64(1);
-                let __ret: [G; OUT_199] = [__v_6];
-                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_203] = [__v_6];
+                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_199] = [__v_6];
-            record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_203] = [__v_6];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; 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_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 __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_199] = [__v_4];
-        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_203] = [__v_4];
+        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -22006,15 +22106,15 @@ fn aiur_fn_199(
   })
 }
 
-const INPUT_SIZE_200: usize = 2;
-const IN_200: usize = 2;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+const INPUT_SIZE_204: usize = 2;
+const IN_204: usize = 2;
+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_200], 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];
@@ -22031,14 +22131,14 @@ fn aiur_fn_200(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].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);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].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);
           },
         }
@@ -22050,16 +22150,16 @@ fn aiur_fn_200(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __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_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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].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);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].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);
           },
         }
@@ -22071,19 +22171,19 @@ fn aiur_fn_200(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4, __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_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 __v_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_200] = [__v_10];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_204] = [__v_10];
+            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].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);
           },
         }
@@ -22095,19 +22195,19 @@ fn aiur_fn_200(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4, __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_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 __v_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_200] = [__v_10];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_204] = [__v_10];
+            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].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);
           },
         }
@@ -22121,14 +22221,14 @@ fn aiur_fn_200(
           4u64 => {
             let __v_8: G = (__v_3 - __v_6);
             let __v_9: G = G::from_bool((__v_8 == G::ZERO));
-            let __ret: [G; OUT_200] = [__v_9];
-            record.function_queries[200].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);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_200] = [__v_8];
-            record.function_queries[200].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);
           },
         }
@@ -22140,15 +22240,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_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_201], 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];
@@ -22165,14 +22265,14 @@ fn aiur_fn_201(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_201] = [__v_8];
-            record.function_queries[201].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);
           },
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_201] = [__v_8];
-            record.function_queries[201].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);
           },
           _ => {
@@ -22188,8 +22288,8 @@ fn aiur_fn_201(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_201] = [__v_8];
-            record.function_queries[201].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);
           },
           0u64 => {
@@ -22197,8 +22297,8 @@ fn aiur_fn_201(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_201] = [__v_9];
-                record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_205] = [__v_9];
+                record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -22206,15 +22306,15 @@ fn aiur_fn_201(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_201] = [__v_10];
-                    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_205] = [__v_10];
+                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_4, __v_7]; 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_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 __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_201] = [__v_10];
-                    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_205] = [__v_10];
+                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -22239,15 +22339,15 @@ fn aiur_fn_201(
   })
 }
 
-const INPUT_SIZE_202: usize = 2;
-const IN_202: usize = 2;
-const OUT_202: usize = 1;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+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_202], 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];
@@ -22258,8 +22358,8 @@ fn aiur_fn_202(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_202] = [__v_5];
-        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_206] = [__v_5];
+        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22270,8 +22370,8 @@ fn aiur_fn_202(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_202] = [__v_8];
-            record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_206] = [__v_8];
+            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22279,25 +22379,25 @@ fn aiur_fn_202(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_202] = [__v_9];
-                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_206] = [__v_9];
+                record.function_queries[206].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_202] = { let __args: [G; IN_202] = [__v_0, __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_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 __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_202] = [__v_10];
-                    record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_206] = [__v_10];
+                    record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_4, __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_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 __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_202] = [__v_10];
-                    record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_206] = [__v_10];
+                    record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -22322,15 +22422,15 @@ fn aiur_fn_202(
   })
 }
 
-const INPUT_SIZE_203: usize = 2;
-const IN_203: usize = 2;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+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_203], 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];
@@ -22347,14 +22447,14 @@ fn aiur_fn_203(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_203] = [__v_8];
-            record.function_queries[203].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_203] = [__v_8];
-            record.function_queries[203].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);
           },
           _ => {
@@ -22370,15 +22470,15 @@ fn aiur_fn_203(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_203] = [__v_8];
-            record.function_queries[203].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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __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 __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_8: G = __r_arr[0];
-            let __ret: [G; OUT_203] = [__v_8];
-            record.function_queries[203].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);
           },
           _ => {
@@ -22393,15 +22493,15 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 2;
-const IN_204: usize = 2;
-const OUT_204: usize = 2;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+const INPUT_SIZE_208: usize = 2;
+const IN_208: usize = 2;
+const OUT_208: usize = 2;
+fn aiur_fn_208(
+  inp: [G; IN_208],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_204], 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];
@@ -22417,8 +22517,8 @@ fn aiur_fn_204(
         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_204] = [__v_5, __v_10];
-        record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_208] = [__v_5, __v_10];
+        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22428,8 +22528,8 @@ fn aiur_fn_204(
             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_204] = [__v_6, __v_8];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_208] = [__v_6, __v_8];
+            record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22437,18 +22537,18 @@ fn aiur_fn_204(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_204] = [__v_7, __v_1];
-                record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_208] = [__v_7, __v_1];
+                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __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 __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 __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_204] = [__v_7, __v_10];
-                record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_208] = [__v_7, __v_10];
+                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -22468,15 +22568,15 @@ fn aiur_fn_204(
   })
 }
 
-const INPUT_SIZE_205: usize = 3;
-const IN_205: usize = 3;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+const INPUT_SIZE_209: usize = 3;
+const IN_209: usize = 3;
+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_205], 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];
@@ -22493,8 +22593,8 @@ fn aiur_fn_205(
         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_205] = [__v_11];
-        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_209] = [__v_11];
+        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22509,8 +22609,8 @@ fn aiur_fn_205(
                 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_205] = [__v_11];
-                record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_209] = [__v_11];
+                record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -22518,11 +22618,11 @@ fn aiur_fn_205(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_1, __v_2]; 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_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 __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_205] = [__v_12];
-                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_209] = [__v_12];
+                    record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -22532,13 +22632,13 @@ fn aiur_fn_205(
                         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_205] = [__v_13];
-                        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_209] = [__v_13];
+                        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __ret: [G; OUT_205] = [__v_0];
-                        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_209] = [__v_0];
+                        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -22565,15 +22665,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_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_206], 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];
@@ -22590,14 +22690,14 @@ fn aiur_fn_206(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_206] = [__v_8];
-            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_210] = [__v_8];
+            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             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_210] = [__v_8];
+            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22613,8 +22713,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_210] = [__v_8];
+            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22634,24 +22734,24 @@ fn aiur_fn_206(
                         let __v_13: G = (__v_9 - __v_11);
                         match __v_13.as_canonical_u64() {
                           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_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 __v_14: G = __r_arr[0];
-                            let __ret: [G; OUT_206] = [__v_14];
-                            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_210] = [__v_14];
+                            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_14: G = G::from_u64(0);
-                            let __ret: [G; OUT_206] = [__v_14];
-                            record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_210] = [__v_14];
+                            record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_206] = [__v_13];
-                        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_210] = [__v_13];
+                        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -22672,15 +22772,15 @@ fn aiur_fn_206(
   })
 }
 
-const INPUT_SIZE_207: usize = 1;
-const IN_207: usize = 1;
-const OUT_207: usize = 1;
-fn aiur_fn_207(
-  inp: [G; IN_207],
+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_207], ExecError> {
+) -> Result<[G; OUT_211], 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 };
@@ -22690,8 +22790,8 @@ fn aiur_fn_207(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_207] = [__v_4];
-        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_211] = [__v_4];
+        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22700,18 +22800,18 @@ fn aiur_fn_207(
         let __v_5: G = __loaded[1];
         match __v_4.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__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 __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 __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_207] = [__v_5];
-                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_211] = [__v_5];
+                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_207] = [__v_6];
-                record.function_queries[207].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);
               },
               _ => {
@@ -22728,15 +22828,15 @@ fn aiur_fn_207(
   })
 }
 
-const INPUT_SIZE_208: usize = 2;
-const IN_208: usize = 2;
-const OUT_208: usize = 1;
-fn aiur_fn_208(
-  inp: [G; IN_208],
+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_208], 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];
@@ -22746,8 +22846,8 @@ fn aiur_fn_208(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_208] = [__v_0];
-        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_212] = [__v_0];
+        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22757,8 +22857,8 @@ fn aiur_fn_208(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_208] = [__v_0];
-            record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_212] = [__v_0];
+            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -22776,21 +22876,21 @@ fn aiur_fn_208(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __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_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_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_208] = [__v_15];
-                        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_212] = [__v_15];
+                        record.function_queries[212].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_208] = { let __args: [G; IN_208] = [__v_0, __v_7]; 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_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 __v_14: G = __r_arr[0];
-                            let __ret: [G; OUT_208] = [__v_14];
-                            record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_212] = [__v_14];
+                            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -22798,18 +22898,18 @@ fn aiur_fn_208(
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_7]; 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_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 __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_208] = [__v_17];
-                                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_212] = [__v_17];
+                                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_7]; 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_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 __v_15: G = __r_arr[0];
-                                let __ret: [G; OUT_208] = [__v_15];
-                                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_212] = [__v_15];
+                                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -22843,23 +22943,23 @@ 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_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_209], 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];
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_209] = [__v_0];
-        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_213] = [__v_0];
+        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -22869,15 +22969,15 @@ fn aiur_fn_209(
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_1, __v_2]; 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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_209] = [__v_6];
-            record.function_queries[209].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 => {
-            let __ret: [G; OUT_209] = [__v_0];
-            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_213] = [__v_0];
+            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -22886,25 +22986,25 @@ fn aiur_fn_209(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_1, __v_2]; 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_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 __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_209] = [__v_3];
-        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_213] = [__v_3];
+        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_210: usize = 3;
-const IN_210: usize = 3;
-const OUT_210: usize = 1;
-fn aiur_fn_210(
-  inp: [G; IN_210],
+const INPUT_SIZE_214: usize = 3;
+const IN_214: usize = 3;
+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_210], ExecError> {
+) -> Result<[G; OUT_214], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22924,8 +23024,8 @@ fn aiur_fn_210(
         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_210] = [__v_14];
-        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_214] = [__v_14];
+        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -22935,7 +23035,7 @@ fn aiur_fn_210(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_6]; 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_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 __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
@@ -22945,13 +23045,13 @@ fn aiur_fn_210(
                     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_210] = [__v_13];
-                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_214] = [__v_13];
+                    record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_210] = [__v_0];
-                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_214] = [__v_0];
+                    record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -22966,17 +23066,17 @@ fn aiur_fn_210(
                 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_210] = [__v_15];
-                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_214] = [__v_15];
+                record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_1, __v_2]; 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_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 __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_210] = [__v_12];
-                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_214] = [__v_12];
+                record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -22990,15 +23090,15 @@ fn aiur_fn_210(
   })
 }
 
-const INPUT_SIZE_211: usize = 4;
-const IN_211: usize = 4;
-const OUT_211: usize = 1;
-fn aiur_fn_211(
-  inp: [G; IN_211],
+const INPUT_SIZE_215: usize = 4;
+const IN_215: usize = 4;
+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_211], 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];
@@ -23023,8 +23123,8 @@ fn aiur_fn_211(
         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_211] = [__v_19];
-        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_215] = [__v_19];
+        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23034,17 +23134,17 @@ fn aiur_fn_211(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_7]; 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_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 __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_205] = { let __args: [G; IN_205] = [__v_9, __v_2, __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 __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 __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_211] = [__v_14];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_215] = [__v_14];
+                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -23058,17 +23158,17 @@ fn aiur_fn_211(
                 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_211] = [__v_20];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_215] = [__v_20];
+                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_6, __v_1, __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 __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 __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_211] = [__v_13];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_215] = [__v_13];
+                record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23082,15 +23182,15 @@ fn aiur_fn_211(
   })
 }
 
-const INPUT_SIZE_212: usize = 4;
-const IN_212: usize = 4;
-const OUT_212: usize = 1;
-fn aiur_fn_212(
-  inp: [G; IN_212],
+const INPUT_SIZE_216: usize = 4;
+const IN_216: usize = 4;
+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_212], 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];
@@ -23102,63 +23202,63 @@ fn aiur_fn_212(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3, __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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_7];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_7];
+        record.function_queries[216].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_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+        let __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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_9];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_9];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_6, __v_1, __v_2, __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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_8];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_8];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_6, __v_1, __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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_212] = [__v_7];
-        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_216] = [__v_7];
+        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __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_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 __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_209] = { let __args: [G; IN_209] = [__v_3, __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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_9, __v_8, __v_5, __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 __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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_212] = [__v_10];
-            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_216] = [__v_10];
+            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_212] = [__v_3];
-                record.function_queries[212].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);
               },
               _ => {
-                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_3, __v_1, __v_5, __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 __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 __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_212] = [__v_9];
-                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_216] = [__v_9];
+                record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23175,15 +23275,15 @@ fn aiur_fn_212(
   })
 }
 
-const INPUT_SIZE_213: usize = 5;
-const IN_213: usize = 5;
-const OUT_213: usize = 1;
-fn aiur_fn_213(
-  inp: [G; IN_213],
+const INPUT_SIZE_217: usize = 5;
+const IN_217: usize = 5;
+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_213], 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];
@@ -23196,55 +23296,55 @@ fn aiur_fn_213(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4, __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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_8];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_217] = [__v_8];
+        record.function_queries[217].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_212] = { let __args: [G; IN_212] = [__v_0, __v_2, __v_3, __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 __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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_6, __v_2, __v_9, __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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_11];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_217] = [__v_11];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_6, __v_2, __v_3, __v_4]; 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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_7, __v_2, __v_3, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_9];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_217] = [__v_9];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_7, __v_2, __v_3, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_213] = [__v_9];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_217] = [__v_9];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __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 __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 __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_209] = { let __args: [G; IN_209] = [__v_4, __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_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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_10, __v_9, __v_6, __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_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 __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_9, __v_3, __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 __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 __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_213] = [__v_12];
-            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_217] = [__v_12];
+            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -23253,17 +23353,17 @@ fn aiur_fn_213(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_2, __v_6, __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_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 __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_212] = { let __args: [G; IN_212] = [__v_0, __v_2, __v_3, __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_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 __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_213] = [__v_11];
-            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_217] = [__v_11];
+            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -23278,15 +23378,15 @@ fn aiur_fn_213(
   })
 }
 
-const INPUT_SIZE_214: usize = 2;
-const IN_214: usize = 2;
-const OUT_214: usize = 1;
-fn aiur_fn_214(
-  inp: [G; IN_214],
+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_214], 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];
@@ -23296,19 +23396,19 @@ fn aiur_fn_214(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_214] = [__v_0];
-        record.function_queries[214].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_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_3, __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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4, __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 __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 __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_214] = [__v_8];
-        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_218] = [__v_8];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -23318,15 +23418,15 @@ fn aiur_fn_214(
   })
 }
 
-const INPUT_SIZE_215: usize = 2;
-const IN_215: usize = 2;
-const OUT_215: usize = 1;
-fn aiur_fn_215(
-  inp: [G; IN_215],
+const INPUT_SIZE_219: usize = 2;
+const IN_219: usize = 2;
+const OUT_219: usize = 1;
+fn aiur_fn_219(
+  inp: [G; IN_219],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_215], ExecError> {
+) -> Result<[G; OUT_219], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23336,8 +23436,8 @@ fn aiur_fn_215(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_215] = [__v_0];
-        record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_219] = [__v_0];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23353,18 +23453,18 @@ fn aiur_fn_215(
             let __v_10: G = __loaded[2];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __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_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 __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_4]; 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_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 __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_215] = [__v_12];
-                    record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_219] = [__v_12];
+                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_5, __v_8]; 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_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 __v_12: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
@@ -23397,7 +23497,7 @@ fn aiur_fn_215(
     break '__mc_2 [__v_17];
   },
   0u64 => {
-    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__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_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 __v_17: G = __r_arr[0];
     let __v_18: G = G::from_u64(1);
     let __v_19: G = (__v_17 + __v_18);
@@ -23438,7 +23538,7 @@ fn aiur_fn_215(
         break '__mc_3 [__v_7];
       },
       0u64 => {
-        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_7, __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 __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 __v_17: G = __r_arr[0];
         break '__mc_3 [__v_17];
       },
@@ -23454,10 +23554,10 @@ fn aiur_fn_215(
  };
                     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_215] = { let __args: [G; IN_215] = [__v_15, __v_4]; 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_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 __v_16: G = __r_arr[0];
-                    let __ret: [G; OUT_215] = [__v_16];
-                    record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_219] = [__v_16];
+                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -23473,15 +23573,15 @@ fn aiur_fn_215(
   })
 }
 
-const INPUT_SIZE_216: usize = 2;
-const IN_216: usize = 2;
-const OUT_216: usize = 1;
-fn aiur_fn_216(
-  inp: [G; IN_216],
+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_216], 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];
@@ -23498,14 +23598,14 @@ fn aiur_fn_216(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_216] = [__v_8];
-            record.function_queries[216].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);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_216] = [__v_8];
-            record.function_queries[216].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);
           },
           _ => {
@@ -23521,8 +23621,8 @@ fn aiur_fn_216(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_216] = [__v_8];
-            record.function_queries[216].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);
           },
           0u64 => {
@@ -23538,27 +23638,27 @@ fn aiur_fn_216(
                 let __v_13: G = __loaded[2];
                 match __v_11.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_11]; 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_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 __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_206] = { let __args: [G; IN_206] = [__v_10, __v_13]; 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_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 __v_16: G = __r_arr[0];
                             match __v_16.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_4, __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_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 __v_17: G = __r_arr[0];
-                                let __ret: [G; OUT_216] = [__v_17];
-                                record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_220] = [__v_17];
+                                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_17: G = G::from_u64(0);
-                                let __ret: [G; OUT_216] = [__v_17];
-                                record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_220] = [__v_17];
+                                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -23568,16 +23668,16 @@ fn aiur_fn_216(
                           },
                           _ => {
                             let __v_16: G = G::from_u64(0);
-                            let __ret: [G; OUT_216] = [__v_16];
-                            record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_220] = [__v_16];
+                            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
-                        let __ret: [G; OUT_216] = [__v_15];
-                        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_220] = [__v_15];
+                        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -23598,15 +23698,15 @@ fn aiur_fn_216(
   })
 }
 
-const INPUT_SIZE_217: usize = 3;
-const IN_217: usize = 3;
-const OUT_217: usize = 1;
-fn aiur_fn_217(
-  inp: [G; IN_217],
+const INPUT_SIZE_221: usize = 3;
+const IN_221: usize = 3;
+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_217], 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];
@@ -23618,8 +23718,8 @@ fn aiur_fn_217(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_217] = [__v_6];
-        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_221] = [__v_6];
+        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23629,14 +23729,14 @@ fn aiur_fn_217(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __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_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 __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                let __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 __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_217] = [__v_10];
-                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_221] = [__v_10];
+                record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -23647,7 +23747,7 @@ fn aiur_fn_217(
     break '__mc_0 [__v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8, __v_2]; 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_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 __v_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -23660,15 +23760,15 @@ fn aiur_fn_217(
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_217] = [__v_12];
-                    record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_221] = [__v_12];
+                    record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                    let __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 __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_221] = [__v_12];
+                    record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23687,15 +23787,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_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_218], 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];
@@ -23706,8 +23806,8 @@ fn aiur_fn_218(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_218] = [__v_5];
-        record.function_queries[218].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);
       },
       0u64 => {
@@ -23722,15 +23822,15 @@ fn aiur_fn_218(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_218] = [__v_10];
-                record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_222] = [__v_10];
+                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                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_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_10: G = __r_arr[0];
-                let __ret: [G; OUT_218] = [__v_10];
-                record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_222] = [__v_10];
+                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -23747,15 +23847,15 @@ fn aiur_fn_218(
   })
 }
 
-const INPUT_SIZE_219: usize = 4;
-const IN_219: usize = 4;
-const OUT_219: usize = 1;
-fn aiur_fn_219(
-  inp: [G; IN_219],
+const INPUT_SIZE_223: usize = 4;
+const IN_223: usize = 4;
+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_219], 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];
@@ -23768,8 +23868,8 @@ fn aiur_fn_219(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_219] = [__v_7];
-        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_223] = [__v_7];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23779,31 +23879,31 @@ fn aiur_fn_219(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7, __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_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 __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_6, __v_1, __v_2, __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 __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 __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_219] = [__v_11];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_223] = [__v_11];
+                record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_9, __v_2, __v_3]; 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_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 __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_219] = [__v_12];
-                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_223] = [__v_12];
+                    record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_6, __v_1, __v_2, __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 __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 __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_223] = [__v_12];
+                    record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23822,15 +23922,15 @@ fn aiur_fn_219(
   })
 }
 
-const INPUT_SIZE_220: usize = 3;
-const IN_220: usize = 3;
-const OUT_220: usize = 1;
-fn aiur_fn_220(
-  inp: [G; IN_220],
+const INPUT_SIZE_224: usize = 3;
+const IN_224: usize = 3;
+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_220], 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];
@@ -23842,8 +23942,8 @@ fn aiur_fn_220(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_220] = [__v_6];
-        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_224] = [__v_6];
+        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23859,15 +23959,15 @@ fn aiur_fn_220(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_220] = [__v_10];
-                    record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_224] = [__v_10];
+                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5, __v_1, __v_2]; 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_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 __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_220] = [__v_10];
-                    record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_224] = [__v_10];
+                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23876,10 +23976,10 @@ fn aiur_fn_220(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5, __v_1, __v_2]; 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_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 __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_220] = [__v_9];
-                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_224] = [__v_9];
+                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -23893,15 +23993,15 @@ fn aiur_fn_220(
   })
 }
 
-const INPUT_SIZE_221: usize = 2;
-const IN_221: usize = 2;
-const OUT_221: usize = 1;
-fn aiur_fn_221(
-  inp: [G; IN_221],
+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_221], 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];
@@ -23912,8 +24012,8 @@ fn aiur_fn_221(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_221] = [__v_5];
-        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_225] = [__v_5];
+        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -23929,7 +24029,7 @@ fn aiur_fn_221(
     break '__mc_0 [__v_8];
   },
   _ => {
-    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1, __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 __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 __v_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -23939,25 +24039,25 @@ fn aiur_fn_221(
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_221] = [__v_9];
-                record.function_queries[221].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);
               },
               1u64 => {
-                let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_7, __v_1, __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 __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 __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_221] = [__v_10];
-                    record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_225] = [__v_10];
+                    record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    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 __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 __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_225] = [__v_10];
+                    record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -23979,15 +24079,15 @@ fn aiur_fn_221(
   })
 }
 
-const INPUT_SIZE_222: usize = 3;
-const IN_222: usize = 3;
-const OUT_222: usize = 1;
-fn aiur_fn_222(
-  inp: [G; IN_222],
+const INPUT_SIZE_226: usize = 3;
+const IN_226: usize = 3;
+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_222], 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];
@@ -23999,8 +24099,8 @@ fn aiur_fn_222(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_222] = [__v_6];
-        record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_226] = [__v_6];
+        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24009,20 +24109,20 @@ fn aiur_fn_222(
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
+            let __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 __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_222] = [__v_9];
-                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_226] = [__v_9];
+                record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __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_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 __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_222] = [__v_9];
-                record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_226] = [__v_9];
+                record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -24039,15 +24139,15 @@ fn aiur_fn_222(
   })
 }
 
-const INPUT_SIZE_223: usize = 1;
-const IN_223: usize = 1;
-const OUT_223: usize = 1;
-fn aiur_fn_223(
-  inp: [G; IN_223],
+const INPUT_SIZE_227: usize = 1;
+const IN_227: usize = 1;
+const OUT_227: usize = 1;
+fn aiur_fn_227(
+  inp: [G; IN_227],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_223], ExecError> {
+) -> Result<[G; OUT_227], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -24067,35 +24167,35 @@ fn aiur_fn_223(
     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_212] = { let __args: [G; IN_212] = [__v_0, __v_16, __v_17, __v_13]; 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_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 __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_18, __v_18]; 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_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 __v_19: G = __r_arr[0];
-    let __ret: [G; OUT_223] = [__v_19];
-    record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_227] = [__v_19];
+    record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_224: usize = 2;
-const IN_224: usize = 2;
-const OUT_224: usize = 1;
-fn aiur_fn_224(
-  inp: [G; IN_224],
+const INPUT_SIZE_228: usize = 2;
+const IN_228: usize = 2;
+const OUT_228: usize = 1;
+fn aiur_fn_228(
+  inp: [G; IN_228],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_224], ExecError> {
+) -> Result<[G; OUT_228], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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_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 __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_224] = [__v_3];
-        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_228] = [__v_3];
+        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -24106,19 +24206,19 @@ fn aiur_fn_224(
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_224] = [__v_6];
-            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_228] = [__v_6];
+            record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0]; 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_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 __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
+            let __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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_224] = [__v_8];
-            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_228] = [__v_8];
+            record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24130,36 +24230,36 @@ 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_229: usize = 2;
+const IN_229: usize = 2;
+const OUT_229: usize = 1;
+fn aiur_fn_229(
+  inp: [G; IN_229],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_225], ExecError> {
+) -> Result<[G; OUT_229], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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_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 __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_225] = [__v_3];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_229] = [__v_3];
+        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0]; 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_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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__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_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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_225] = [__v_5];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_229] = [__v_5];
+        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24169,15 +24269,15 @@ fn aiur_fn_225(
   })
 }
 
-const INPUT_SIZE_226: usize = 2;
-const IN_226: usize = 2;
-const OUT_226: usize = 1;
-fn aiur_fn_226(
-  inp: [G; IN_226],
+const INPUT_SIZE_230: usize = 2;
+const IN_230: usize = 2;
+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_226], ExecError> {
+) -> Result<[G; OUT_230], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24187,8 +24287,8 @@ fn aiur_fn_226(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_226] = [__v_1];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_230] = [__v_1];
+        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24198,17 +24298,17 @@ fn aiur_fn_226(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_226] = [__v_0];
-            record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_230] = [__v_0];
+            record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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_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 __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_226] = [__v_0];
-                record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_230] = [__v_0];
+                record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -24225,19 +24325,19 @@ fn aiur_fn_226(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_15: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_10, __v_13]; 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_230] = { let __args: [G; IN_230] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
                         let __v_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_226] = [__v_18];
-                        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_230] = [__v_18];
+                        record.function_queries[230].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_226] = [__v_16];
-                        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_230] = [__v_16];
+                        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -24245,8 +24345,8 @@ fn aiur_fn_226(
                   _ => {
                     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_226] = [__v_13];
-                    record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_230] = [__v_13];
+                    record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -24262,15 +24362,15 @@ fn aiur_fn_226(
   })
 }
 
-const INPUT_SIZE_227: usize = 2;
-const IN_227: usize = 2;
-const OUT_227: usize = 1;
-fn aiur_fn_227(
-  inp: [G; IN_227],
+const INPUT_SIZE_231: usize = 2;
+const IN_231: usize = 2;
+const OUT_231: usize = 1;
+fn aiur_fn_231(
+  inp: [G; IN_231],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_227], ExecError> {
+) -> Result<[G; OUT_231], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24283,26 +24383,26 @@ fn aiur_fn_227(
         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_227] = [__v_7];
-        record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_231] = [__v_7];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_227] = [__v_5];
-        record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_231] = [__v_5];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__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 __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 __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+            let __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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_227] = [__v_6];
-            record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_231] = [__v_6];
+            record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -24312,24 +24412,24 @@ fn aiur_fn_227(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_227] = [__v_1];
-                record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_231] = [__v_1];
+                record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __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_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 __v_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_227] = [__v_0];
-                    record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_231] = [__v_0];
+                    record.function_queries[231].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_227] = [__v_11];
-                    record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_231] = [__v_11];
+                    record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -24348,15 +24448,15 @@ fn aiur_fn_227(
   })
 }
 
-const INPUT_SIZE_228: usize = 1;
-const IN_228: usize = 1;
-const OUT_228: usize = 1;
-fn aiur_fn_228(
-  inp: [G; IN_228],
+const INPUT_SIZE_232: usize = 1;
+const IN_232: usize = 1;
+const OUT_232: usize = 1;
+fn aiur_fn_232(
+  inp: [G; IN_232],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_228], ExecError> {
+) -> Result<[G; OUT_232], 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 };
@@ -24368,48 +24468,48 @@ fn aiur_fn_228(
         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_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_6];
+        record.function_queries[232].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_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_6];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __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 __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_228] = [__v_7];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_7];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __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 __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __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_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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_6];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __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 __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4, __v_5]; 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_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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_228] = [__v_6];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_232] = [__v_6];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24419,15 +24519,15 @@ 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_233: usize = 2;
+const IN_233: usize = 2;
+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_229], ExecError> {
+) -> Result<[G; OUT_233], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24440,47 +24540,47 @@ fn aiur_fn_229(
         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_229] = [__v_7];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_233] = [__v_7];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __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 __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_229] = [__v_8];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_233] = [__v_8];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_5, __v_6]; 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_230] = { let __args: [G; IN_230] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_229] = [__v_7];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_233] = [__v_7];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; 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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_229] = [__v_7];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_233] = [__v_7];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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_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_233] = [__v_5];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24490,15 +24590,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_234: usize = 2;
+const IN_234: usize = 2;
+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_230], ExecError> {
+) -> Result<[G; OUT_234], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24511,19 +24611,19 @@ fn aiur_fn_230(
         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_230] = [__v_7];
-        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_234] = [__v_7];
+        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __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_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 __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_230] = [__v_8];
-        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_234] = [__v_8];
+        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24533,15 +24633,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_235: usize = 2;
+const IN_235: usize = 2;
+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_231], ExecError> {
+) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24551,30 +24651,30 @@ fn aiur_fn_231(
     let __v_4: G = __loaded[2];
     match __v_2.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_235] = [__v_0];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1]; 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_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 __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_235] = [__v_5];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_232: usize = 2;
-const IN_232: usize = 2;
-const OUT_232: usize = 1;
-fn aiur_fn_232(
-  inp: [G; IN_232],
+const INPUT_SIZE_236: usize = 2;
+const IN_236: usize = 2;
+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_232], ExecError> {
+) -> Result<[G; OUT_236], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24588,94 +24688,94 @@ fn aiur_fn_232(
         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_232] = [__v_8];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_8];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __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 __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_232] = [__v_9];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_9];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(2);
-        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __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_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 __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_232] = [__v_9];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_9];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_6: G = G::from_u64(3);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_10];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_6: G = G::from_u64(4);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_10];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_6: G = G::from_u64(5);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_10];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(6);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __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_232] = [__v_10];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_10];
+        record.function_queries[236].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_232] = [__v_8];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_8];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_6: G = G::from_u64(8);
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+        let __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 __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_232] = [__v_8];
-        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_236] = [__v_8];
+        record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -24685,15 +24785,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_237: usize = 2;
+const IN_237: usize = 2;
+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_233], ExecError> {
+) -> Result<[G; OUT_237], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24724,14 +24824,14 @@ fn aiur_fn_233(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_233] = [__v_22];
-            record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_237] = [__v_22];
+            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_233] = [__v_22];
-            record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_237] = [__v_22];
+            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24751,25 +24851,25 @@ fn aiur_fn_233(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_233] = [__v_22];
-            record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_237] = [__v_22];
+            record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__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[6].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_6] = unsafe { *(result.output.as_ptr() as *const [G; OUT_6]) }; __ret } else { aiur_fn_6(__args, record, io_buffer, __cu)? } };
+            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 __v_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_11, __v_21]; 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_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 __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_233] = [__v_23];
-                record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_237] = [__v_23];
+                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_233] = [__v_23];
-                record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_237] = [__v_23];
+                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -24789,15 +24889,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_238: usize = 2;
+const IN_238: usize = 2;
+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_234], ExecError> {
+) -> Result<[G; OUT_238], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24814,14 +24914,14 @@ fn aiur_fn_234(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_234] = [__v_8];
-            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_238] = [__v_8];
+            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_234] = [__v_8];
-            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_238] = [__v_8];
+            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24834,24 +24934,24 @@ fn aiur_fn_234(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_234] = [__v_8];
-            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_238] = [__v_8];
+            record.function_queries[238].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_234] = { let __args: [G; IN_234] = [__v_4, __v_7]; 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_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 __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_234] = [__v_9];
-                record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_238] = [__v_9];
+                record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_234] = [__v_9];
-                record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_238] = [__v_9];
+                record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -24868,15 +24968,15 @@ fn aiur_fn_234(
   })
 }
 
-const INPUT_SIZE_235: usize = 4;
-const IN_235: usize = 4;
-const OUT_235: usize = 1;
-fn aiur_fn_235(
-  inp: [G; IN_235],
+const INPUT_SIZE_239: usize = 4;
+const IN_239: usize = 4;
+const OUT_239: usize = 1;
+fn aiur_fn_239(
+  inp: [G; IN_239],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_235], ExecError> {
+) -> Result<[G; OUT_239], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24886,16 +24986,16 @@ fn aiur_fn_235(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_239] = [__v_4];
+            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_239] = [__v_4];
+            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24903,16 +25003,16 @@ fn aiur_fn_235(
       1u64 => {
         match __v_2.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_239] = [__v_4];
+            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_235] = [__v_4];
-            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_239] = [__v_4];
+            record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -24924,15 +25024,15 @@ fn aiur_fn_235(
   })
 }
 
-const INPUT_SIZE_236: usize = 0;
-const IN_236: usize = 0;
-const OUT_236: usize = 1;
-fn aiur_fn_236(
-  inp: [G; IN_236],
+const INPUT_SIZE_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_236], ExecError> {
+) -> Result<[G; OUT_240], 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);
@@ -24967,21 +25067,21 @@ fn aiur_fn_236(
     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_236] = [__v_32];
-    record.function_queries[236].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_237: usize = 0;
-const IN_237: usize = 0;
-const OUT_237: usize = 1;
-fn aiur_fn_237(
-  inp: [G; IN_237],
+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_237], ExecError> {
+) -> Result<[G; OUT_241], 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);
@@ -25016,21 +25116,21 @@ fn aiur_fn_237(
     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_237] = [__v_32];
-    record.function_queries[237].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_238: usize = 0;
-const IN_238: usize = 0;
-const OUT_238: usize = 1;
-fn aiur_fn_238(
-  inp: [G; IN_238],
+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_238], ExecError> {
+) -> Result<[G; OUT_242], 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);
@@ -25065,21 +25165,21 @@ fn aiur_fn_238(
     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_238] = [__v_32];
-    record.function_queries[238].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_239: usize = 0;
-const IN_239: usize = 0;
-const OUT_239: usize = 1;
-fn aiur_fn_239(
-  inp: [G; IN_239],
+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_239], ExecError> {
+) -> Result<[G; OUT_243], 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);
@@ -25114,21 +25214,21 @@ fn aiur_fn_239(
     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_239] = [__v_32];
-    record.function_queries[239].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_240: usize = 0;
-const IN_240: usize = 0;
-const OUT_240: usize = 1;
-fn aiur_fn_240(
-  inp: [G; IN_240],
+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_240], ExecError> {
+) -> Result<[G; OUT_244], 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);
@@ -25163,21 +25263,21 @@ fn aiur_fn_240(
     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_240] = [__v_32];
-    record.function_queries[240].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_241: usize = 0;
-const IN_241: usize = 0;
-const OUT_241: usize = 1;
-fn aiur_fn_241(
-  inp: [G; IN_241],
+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_241], ExecError> {
+) -> Result<[G; OUT_245], 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);
@@ -25212,21 +25312,21 @@ fn aiur_fn_241(
     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_241] = [__v_32];
-    record.function_queries[241].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_242: usize = 0;
-const IN_242: usize = 0;
-const OUT_242: usize = 1;
-fn aiur_fn_242(
-  inp: [G; IN_242],
+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_242], ExecError> {
+) -> Result<[G; OUT_246], 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);
@@ -25261,21 +25361,21 @@ fn aiur_fn_242(
     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_242] = [__v_32];
-    record.function_queries[242].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_243: usize = 0;
-const IN_243: usize = 0;
-const OUT_243: usize = 1;
-fn aiur_fn_243(
-  inp: [G; IN_243],
+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_243], ExecError> {
+) -> Result<[G; OUT_247], 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);
@@ -25310,21 +25410,21 @@ fn aiur_fn_243(
     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_243] = [__v_32];
-    record.function_queries[243].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_244: usize = 0;
-const IN_244: usize = 0;
-const OUT_244: usize = 1;
-fn aiur_fn_244(
-  inp: [G; IN_244],
+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_244], ExecError> {
+) -> Result<[G; OUT_248], 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);
@@ -25359,21 +25459,21 @@ fn aiur_fn_244(
     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_244] = [__v_32];
-    record.function_queries[244].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_245: usize = 0;
-const IN_245: usize = 0;
-const OUT_245: usize = 1;
-fn aiur_fn_245(
-  inp: [G; IN_245],
+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_245], ExecError> {
+) -> Result<[G; OUT_249], 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);
@@ -25408,21 +25508,21 @@ fn aiur_fn_245(
     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_245] = [__v_32];
-    record.function_queries[245].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_246: usize = 0;
-const IN_246: usize = 0;
-const OUT_246: usize = 1;
-fn aiur_fn_246(
-  inp: [G; IN_246],
+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_246], ExecError> {
+) -> Result<[G; OUT_250], 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);
@@ -25457,21 +25557,21 @@ fn aiur_fn_246(
     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_246] = [__v_32];
-    record.function_queries[246].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_247: usize = 0;
-const IN_247: usize = 0;
-const OUT_247: usize = 1;
-fn aiur_fn_247(
-  inp: [G; IN_247],
+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_247], ExecError> {
+) -> Result<[G; OUT_251], 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);
@@ -25506,21 +25606,21 @@ fn aiur_fn_247(
     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_247] = [__v_32];
-    record.function_queries[247].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_248: usize = 0;
-const IN_248: usize = 0;
-const OUT_248: usize = 1;
-fn aiur_fn_248(
-  inp: [G; IN_248],
+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_248], ExecError> {
+) -> Result<[G; OUT_252], 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);
@@ -25555,21 +25655,21 @@ fn aiur_fn_248(
     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_248] = [__v_32];
-    record.function_queries[248].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_249: usize = 0;
-const IN_249: usize = 0;
-const OUT_249: usize = 1;
-fn aiur_fn_249(
-  inp: [G; IN_249],
+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_249], ExecError> {
+) -> Result<[G; OUT_253], 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);
@@ -25604,21 +25704,21 @@ fn aiur_fn_249(
     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_249] = [__v_32];
-    record.function_queries[249].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_250: usize = 0;
-const IN_250: usize = 0;
-const OUT_250: usize = 1;
-fn aiur_fn_250(
-  inp: [G; IN_250],
+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_250], ExecError> {
+) -> Result<[G; OUT_254], 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);
@@ -25653,21 +25753,21 @@ fn aiur_fn_250(
     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_250] = [__v_32];
-    record.function_queries[250].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_251: usize = 0;
-const IN_251: usize = 0;
-const OUT_251: usize = 1;
-fn aiur_fn_251(
-  inp: [G; IN_251],
+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_251], ExecError> {
+) -> Result<[G; OUT_255], 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);
@@ -25702,21 +25802,21 @@ fn aiur_fn_251(
     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_251] = [__v_32];
-    record.function_queries[251].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_252: usize = 0;
-const IN_252: usize = 0;
-const OUT_252: usize = 1;
-fn aiur_fn_252(
-  inp: [G; IN_252],
+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_252], ExecError> {
+) -> Result<[G; OUT_256], 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);
@@ -25751,21 +25851,21 @@ fn aiur_fn_252(
     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_252] = [__v_32];
-    record.function_queries[252].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_253: usize = 0;
-const IN_253: usize = 0;
-const OUT_253: usize = 1;
-fn aiur_fn_253(
-  inp: [G; IN_253],
+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_253], ExecError> {
+) -> Result<[G; OUT_257], 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);
@@ -25800,21 +25900,21 @@ fn aiur_fn_253(
     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_253] = [__v_32];
-    record.function_queries[253].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_254: usize = 0;
-const IN_254: usize = 0;
-const OUT_254: usize = 1;
-fn aiur_fn_254(
-  inp: [G; IN_254],
+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_254], ExecError> {
+) -> Result<[G; OUT_258], 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);
@@ -25849,21 +25949,21 @@ fn aiur_fn_254(
     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_254] = [__v_32];
-    record.function_queries[254].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_255: usize = 0;
-const IN_255: usize = 0;
-const OUT_255: usize = 1;
-fn aiur_fn_255(
-  inp: [G; IN_255],
+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_255], ExecError> {
+) -> Result<[G; OUT_259], 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);
@@ -25898,21 +25998,21 @@ fn aiur_fn_255(
     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_255] = [__v_32];
-    record.function_queries[255].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_256: usize = 0;
-const IN_256: usize = 0;
-const OUT_256: usize = 1;
-fn aiur_fn_256(
-  inp: [G; IN_256],
+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_256], ExecError> {
+) -> Result<[G; OUT_260], 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);
@@ -25947,21 +26047,21 @@ fn aiur_fn_256(
     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_256] = [__v_32];
-    record.function_queries[256].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_257: usize = 0;
-const IN_257: usize = 0;
-const OUT_257: usize = 1;
-fn aiur_fn_257(
-  inp: [G; IN_257],
+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_257], ExecError> {
+) -> Result<[G; OUT_261], 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);
@@ -25996,21 +26096,21 @@ fn aiur_fn_257(
     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_257] = [__v_32];
-    record.function_queries[257].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_258: usize = 0;
-const IN_258: usize = 0;
-const OUT_258: usize = 1;
-fn aiur_fn_258(
-  inp: [G; IN_258],
+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_258], ExecError> {
+) -> Result<[G; OUT_262], 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);
@@ -26045,21 +26145,21 @@ fn aiur_fn_258(
     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_258] = [__v_32];
-    record.function_queries[258].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_259: usize = 0;
-const IN_259: usize = 0;
-const OUT_259: usize = 1;
-fn aiur_fn_259(
-  inp: [G; IN_259],
+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_259], ExecError> {
+) -> Result<[G; OUT_263], 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);
@@ -26094,21 +26194,21 @@ fn aiur_fn_259(
     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_259] = [__v_32];
-    record.function_queries[259].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_260: usize = 0;
-const IN_260: usize = 0;
-const OUT_260: usize = 1;
-fn aiur_fn_260(
-  inp: [G; IN_260],
+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_260], ExecError> {
+) -> Result<[G; OUT_264], 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);
@@ -26143,21 +26243,21 @@ fn aiur_fn_260(
     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_260] = [__v_32];
-    record.function_queries[260].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_261: usize = 0;
-const IN_261: usize = 0;
-const OUT_261: usize = 1;
-fn aiur_fn_261(
-  inp: [G; IN_261],
+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_261], ExecError> {
+) -> Result<[G; OUT_265], 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);
@@ -26192,21 +26292,21 @@ fn aiur_fn_261(
     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_261] = [__v_32];
-    record.function_queries[261].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_262: usize = 0;
-const IN_262: usize = 0;
-const OUT_262: usize = 1;
-fn aiur_fn_262(
-  inp: [G; IN_262],
+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_262], ExecError> {
+) -> Result<[G; OUT_266], 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);
@@ -26241,21 +26341,21 @@ fn aiur_fn_262(
     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_262] = [__v_32];
-    record.function_queries[262].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_263: usize = 0;
-const IN_263: usize = 0;
-const OUT_263: usize = 1;
-fn aiur_fn_263(
-  inp: [G; IN_263],
+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_263], ExecError> {
+) -> Result<[G; OUT_267], 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);
@@ -26290,21 +26390,21 @@ fn aiur_fn_263(
     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_263] = [__v_32];
-    record.function_queries[263].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_264: usize = 0;
-const IN_264: usize = 0;
-const OUT_264: usize = 1;
-fn aiur_fn_264(
-  inp: [G; IN_264],
+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_264], ExecError> {
+) -> Result<[G; OUT_268], 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);
@@ -26339,21 +26439,21 @@ fn aiur_fn_264(
     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_264] = [__v_32];
-    record.function_queries[264].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_265: usize = 0;
-const IN_265: usize = 0;
-const OUT_265: usize = 1;
-fn aiur_fn_265(
-  inp: [G; IN_265],
+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_265], ExecError> {
+) -> Result<[G; OUT_269], 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);
@@ -26388,21 +26488,21 @@ fn aiur_fn_265(
     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_265] = [__v_32];
-    record.function_queries[265].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_266: usize = 0;
-const IN_266: usize = 0;
-const OUT_266: usize = 1;
-fn aiur_fn_266(
-  inp: [G; IN_266],
+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_266], ExecError> {
+) -> Result<[G; OUT_270], 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);
@@ -26437,21 +26537,21 @@ fn aiur_fn_266(
     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_266] = [__v_32];
-    record.function_queries[266].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_267: usize = 0;
-const IN_267: usize = 0;
-const OUT_267: usize = 1;
-fn aiur_fn_267(
-  inp: [G; IN_267],
+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_267], ExecError> {
+) -> Result<[G; OUT_271], 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);
@@ -26486,21 +26586,21 @@ fn aiur_fn_267(
     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_267] = [__v_32];
-    record.function_queries[267].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_268: usize = 0;
-const IN_268: usize = 0;
-const OUT_268: usize = 1;
-fn aiur_fn_268(
-  inp: [G; IN_268],
+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_268], ExecError> {
+) -> Result<[G; OUT_272], 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);
@@ -26535,21 +26635,21 @@ fn aiur_fn_268(
     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_268] = [__v_32];
-    record.function_queries[268].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_269: usize = 0;
-const IN_269: usize = 0;
-const OUT_269: usize = 1;
-fn aiur_fn_269(
-  inp: [G; IN_269],
+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_269], ExecError> {
+) -> Result<[G; OUT_273], 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);
@@ -26584,21 +26684,21 @@ fn aiur_fn_269(
     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_269] = [__v_32];
-    record.function_queries[269].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_270: usize = 0;
-const IN_270: usize = 0;
-const OUT_270: usize = 1;
-fn aiur_fn_270(
-  inp: [G; IN_270],
+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_270], ExecError> {
+) -> Result<[G; OUT_274], 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);
@@ -26633,21 +26733,21 @@ fn aiur_fn_270(
     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_270] = [__v_32];
-    record.function_queries[270].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_271: usize = 0;
-const IN_271: usize = 0;
-const OUT_271: usize = 1;
-fn aiur_fn_271(
-  inp: [G; IN_271],
+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_271], ExecError> {
+) -> Result<[G; OUT_275], 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);
@@ -26682,21 +26782,21 @@ fn aiur_fn_271(
     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_271] = [__v_32];
-    record.function_queries[271].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_272: usize = 0;
-const IN_272: usize = 0;
-const OUT_272: usize = 1;
-fn aiur_fn_272(
-  inp: [G; IN_272],
+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_272], ExecError> {
+) -> Result<[G; OUT_276], 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);
@@ -26731,21 +26831,21 @@ fn aiur_fn_272(
     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_272] = [__v_32];
-    record.function_queries[272].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_273: usize = 0;
-const IN_273: usize = 0;
-const OUT_273: usize = 1;
-fn aiur_fn_273(
-  inp: [G; IN_273],
+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_273], ExecError> {
+) -> Result<[G; OUT_277], 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);
@@ -26780,21 +26880,21 @@ fn aiur_fn_273(
     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_273] = [__v_32];
-    record.function_queries[273].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_274: usize = 0;
-const IN_274: usize = 0;
-const OUT_274: usize = 1;
-fn aiur_fn_274(
-  inp: [G; IN_274],
+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_274], ExecError> {
+) -> Result<[G; OUT_278], 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);
@@ -26829,21 +26929,21 @@ fn aiur_fn_274(
     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_274] = [__v_32];
-    record.function_queries[274].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_275: usize = 0;
-const IN_275: usize = 0;
-const OUT_275: usize = 1;
-fn aiur_fn_275(
-  inp: [G; IN_275],
+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_275], ExecError> {
+) -> Result<[G; OUT_279], 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);
@@ -26878,21 +26978,21 @@ fn aiur_fn_275(
     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_275] = [__v_32];
-    record.function_queries[275].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_276: usize = 0;
-const IN_276: usize = 0;
-const OUT_276: usize = 1;
-fn aiur_fn_276(
-  inp: [G; IN_276],
+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_276], ExecError> {
+) -> Result<[G; OUT_280], 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);
@@ -26927,21 +27027,21 @@ fn aiur_fn_276(
     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_276] = [__v_32];
-    record.function_queries[276].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_277: usize = 0;
-const IN_277: usize = 0;
-const OUT_277: usize = 1;
-fn aiur_fn_277(
-  inp: [G; IN_277],
+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_277], ExecError> {
+) -> Result<[G; OUT_281], 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);
@@ -26976,21 +27076,21 @@ fn aiur_fn_277(
     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_277] = [__v_32];
-    record.function_queries[277].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_278: usize = 0;
-const IN_278: usize = 0;
-const OUT_278: usize = 1;
-fn aiur_fn_278(
-  inp: [G; IN_278],
+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_278], ExecError> {
+) -> Result<[G; OUT_282], 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);
@@ -27025,21 +27125,21 @@ fn aiur_fn_278(
     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_278] = [__v_32];
-    record.function_queries[278].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_279: usize = 0;
-const IN_279: usize = 0;
-const OUT_279: usize = 1;
-fn aiur_fn_279(
-  inp: [G; IN_279],
+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_279], ExecError> {
+) -> Result<[G; OUT_283], 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);
@@ -27074,21 +27174,21 @@ fn aiur_fn_279(
     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_279] = [__v_32];
-    record.function_queries[279].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_280: usize = 0;
-const IN_280: usize = 0;
-const OUT_280: usize = 1;
-fn aiur_fn_280(
-  inp: [G; IN_280],
+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_280], ExecError> {
+) -> Result<[G; OUT_284], 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);
@@ -27123,21 +27223,21 @@ fn aiur_fn_280(
     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_280] = [__v_32];
-    record.function_queries[280].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_281: usize = 0;
-const IN_281: usize = 0;
-const OUT_281: usize = 1;
-fn aiur_fn_281(
-  inp: [G; IN_281],
+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_281], ExecError> {
+) -> Result<[G; OUT_285], 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);
@@ -27172,21 +27272,21 @@ fn aiur_fn_281(
     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_281] = [__v_32];
-    record.function_queries[281].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_282: usize = 0;
-const IN_282: usize = 0;
-const OUT_282: usize = 1;
-fn aiur_fn_282(
-  inp: [G; IN_282],
+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_282], ExecError> {
+) -> Result<[G; OUT_286], 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);
@@ -27221,21 +27321,21 @@ fn aiur_fn_282(
     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_282] = [__v_32];
-    record.function_queries[282].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_283: usize = 0;
-const IN_283: usize = 0;
-const OUT_283: usize = 1;
-fn aiur_fn_283(
-  inp: [G; IN_283],
+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_283], ExecError> {
+) -> Result<[G; OUT_287], 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);
@@ -27270,21 +27370,21 @@ fn aiur_fn_283(
     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_283] = [__v_32];
-    record.function_queries[283].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_284: usize = 0;
-const IN_284: usize = 0;
-const OUT_284: usize = 1;
-fn aiur_fn_284(
-  inp: [G; IN_284],
+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_284], ExecError> {
+) -> Result<[G; OUT_288], 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);
@@ -27319,21 +27419,21 @@ fn aiur_fn_284(
     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_284] = [__v_32];
-    record.function_queries[284].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_285: usize = 0;
-const IN_285: usize = 0;
-const OUT_285: usize = 1;
-fn aiur_fn_285(
-  inp: [G; IN_285],
+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_285], ExecError> {
+) -> Result<[G; OUT_289], 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);
@@ -27368,21 +27468,21 @@ fn aiur_fn_285(
     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_285] = [__v_32];
-    record.function_queries[285].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_286: usize = 0;
-const IN_286: usize = 0;
-const OUT_286: usize = 1;
-fn aiur_fn_286(
-  inp: [G; IN_286],
+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_286], ExecError> {
+) -> Result<[G; OUT_290], 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);
@@ -27417,21 +27517,21 @@ fn aiur_fn_286(
     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_286] = [__v_32];
-    record.function_queries[286].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_287: usize = 0;
-const IN_287: usize = 0;
-const OUT_287: usize = 1;
-fn aiur_fn_287(
-  inp: [G; IN_287],
+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_287], ExecError> {
+) -> Result<[G; OUT_291], 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);
@@ -27466,21 +27566,21 @@ fn aiur_fn_287(
     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_287] = [__v_32];
-    record.function_queries[287].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_288: usize = 0;
-const IN_288: usize = 0;
-const OUT_288: usize = 1;
-fn aiur_fn_288(
-  inp: [G; IN_288],
+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_288], ExecError> {
+) -> Result<[G; OUT_292], 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);
@@ -27515,21 +27615,21 @@ fn aiur_fn_288(
     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_288] = [__v_32];
-    record.function_queries[288].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_289: usize = 0;
-const IN_289: usize = 0;
-const OUT_289: usize = 1;
-fn aiur_fn_289(
-  inp: [G; IN_289],
+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_289], ExecError> {
+) -> Result<[G; OUT_293], 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);
@@ -27564,21 +27664,21 @@ fn aiur_fn_289(
     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_289] = [__v_32];
-    record.function_queries[289].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_290: usize = 0;
-const IN_290: usize = 0;
-const OUT_290: usize = 1;
-fn aiur_fn_290(
-  inp: [G; IN_290],
+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_290], ExecError> {
+) -> Result<[G; OUT_294], 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);
@@ -27613,21 +27713,21 @@ fn aiur_fn_290(
     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_290] = [__v_32];
-    record.function_queries[290].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_291: usize = 0;
-const IN_291: usize = 0;
-const OUT_291: usize = 1;
-fn aiur_fn_291(
-  inp: [G; IN_291],
+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_291], ExecError> {
+) -> Result<[G; OUT_295], 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);
@@ -27662,21 +27762,21 @@ fn aiur_fn_291(
     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_291] = [__v_32];
-    record.function_queries[291].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_292: usize = 0;
-const IN_292: usize = 0;
-const OUT_292: usize = 1;
-fn aiur_fn_292(
-  inp: [G; IN_292],
+const INPUT_SIZE_296: usize = 0;
+const IN_296: usize = 0;
+const OUT_296: usize = 1;
+fn aiur_fn_296(
+  inp: [G; IN_296],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_292], ExecError> {
+) -> Result<[G; OUT_296], 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);
@@ -27711,21 +27811,21 @@ fn aiur_fn_292(
     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_292] = [__v_32];
-    record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_296] = [__v_32];
+    record.function_queries[296].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_297: usize = 0;
+const IN_297: usize = 0;
+const OUT_297: usize = 1;
+fn aiur_fn_297(
+  inp: [G; IN_297],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_293], ExecError> {
+) -> Result<[G; OUT_297], 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);
@@ -27760,21 +27860,21 @@ fn aiur_fn_293(
     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_293] = [__v_32];
-    record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_297] = [__v_32];
+    record.function_queries[297].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_298: usize = 0;
+const IN_298: usize = 0;
+const OUT_298: usize = 1;
+fn aiur_fn_298(
+  inp: [G; IN_298],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_294], ExecError> {
+) -> Result<[G; OUT_298], 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);
@@ -27809,21 +27909,21 @@ fn aiur_fn_294(
     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_294] = [__v_32];
-    record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_298] = [__v_32];
+    record.function_queries[298].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_299: usize = 0;
+const IN_299: usize = 0;
+const OUT_299: usize = 1;
+fn aiur_fn_299(
+  inp: [G; IN_299],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_295], ExecError> {
+) -> Result<[G; OUT_299], 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);
@@ -27858,21 +27958,21 @@ fn aiur_fn_295(
     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_295] = [__v_32];
-    record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_299] = [__v_32];
+    record.function_queries[299].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_300: usize = 0;
+const IN_300: usize = 0;
+const OUT_300: usize = 1;
+fn aiur_fn_300(
+  inp: [G; IN_300],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_296], ExecError> {
+) -> Result<[G; OUT_300], 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);
@@ -27907,21 +28007,21 @@ fn aiur_fn_296(
     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_296] = [__v_32];
-    record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_300] = [__v_32];
+    record.function_queries[300].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_301: usize = 0;
+const IN_301: usize = 0;
+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_297], ExecError> {
+) -> Result<[G; OUT_301], 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);
@@ -27956,21 +28056,21 @@ fn aiur_fn_297(
     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_297] = [__v_32];
-    record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_301] = [__v_32];
+    record.function_queries[301].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_302: usize = 0;
+const IN_302: usize = 0;
+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_298], ExecError> {
+) -> Result<[G; OUT_302], 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);
@@ -28005,21 +28105,21 @@ fn aiur_fn_298(
     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_298] = [__v_32];
-    record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_302] = [__v_32];
+    record.function_queries[302].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_303: usize = 0;
+const IN_303: usize = 0;
+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_299], ExecError> {
+) -> Result<[G; OUT_303], 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);
@@ -28054,21 +28154,21 @@ fn aiur_fn_299(
     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_299] = [__v_32];
-    record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_303] = [__v_32];
+    record.function_queries[303].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_304: usize = 0;
+const IN_304: usize = 0;
+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_300], ExecError> {
+) -> Result<[G; OUT_304], 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);
@@ -28103,21 +28203,21 @@ fn aiur_fn_300(
     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_300] = [__v_32];
-    record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_304] = [__v_32];
+    record.function_queries[304].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_305: usize = 0;
+const IN_305: usize = 0;
+const OUT_305: usize = 1;
+fn aiur_fn_305(
+  inp: [G; IN_305],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_301], ExecError> {
+) -> Result<[G; OUT_305], 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);
@@ -28152,21 +28252,21 @@ fn aiur_fn_301(
     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_301] = [__v_32];
-    record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_305] = [__v_32];
+    record.function_queries[305].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_306: usize = 0;
+const IN_306: usize = 0;
+const OUT_306: usize = 1;
+fn aiur_fn_306(
+  inp: [G; IN_306],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_302], ExecError> {
+) -> Result<[G; OUT_306], 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);
@@ -28201,21 +28301,21 @@ fn aiur_fn_302(
     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_302] = [__v_32];
-    record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_306] = [__v_32];
+    record.function_queries[306].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_307: usize = 0;
+const IN_307: usize = 0;
+const OUT_307: usize = 1;
+fn aiur_fn_307(
+  inp: [G; IN_307],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_303], ExecError> {
+) -> Result<[G; OUT_307], 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);
@@ -28250,21 +28350,21 @@ fn aiur_fn_303(
     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_303] = [__v_32];
-    record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_307] = [__v_32];
+    record.function_queries[307].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_308: usize = 0;
+const IN_308: usize = 0;
+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_304], ExecError> {
+) -> Result<[G; OUT_308], 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);
@@ -28299,21 +28399,21 @@ fn aiur_fn_304(
     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_304] = [__v_32];
-    record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_308] = [__v_32];
+    record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_305: usize = 1;
-const IN_305: usize = 1;
-const OUT_305: usize = 1;
-fn aiur_fn_305(
-  inp: [G; IN_305],
+const INPUT_SIZE_309: usize = 1;
+const IN_309: usize = 1;
+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_305], ExecError> {
+) -> Result<[G; OUT_309], 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 };
@@ -28342,8 +28442,8 @@ fn aiur_fn_305(
         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_305] = [__v_23];
-        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_309] = [__v_23];
+        record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -28355,7 +28455,7 @@ fn aiur_fn_305(
         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_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+        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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -28369,17 +28469,17 @@ fn aiur_fn_305(
           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_305] = [__v_29];
-            record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_309] = [__v_29];
+            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
             let __v_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_305] = [__v_30];
-            record.function_queries[305].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);
           },
         }
@@ -28391,15 +28491,15 @@ fn aiur_fn_305(
   })
 }
 
-const INPUT_SIZE_306: usize = 3;
-const IN_306: usize = 3;
-const OUT_306: usize = 1;
-fn aiur_fn_306(
-  inp: [G; IN_306],
+const INPUT_SIZE_310: usize = 3;
+const IN_310: usize = 3;
+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_306], 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];
@@ -28419,15 +28519,15 @@ fn aiur_fn_306(
       1u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_306] = [__v_1];
-            record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_310] = [__v_1];
+            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__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 __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_306] = [__v_13];
-            record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_310] = [__v_13];
+            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -28448,21 +28548,21 @@ fn aiur_fn_306(
           1u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_306] = [__v_0];
-                record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_310] = [__v_0];
+                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0]; 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_309] = { let __args: [G; IN_309] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_306] = [__v_23];
-                record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_310] = [__v_23];
+                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__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, __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 __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -28479,7 +28579,7 @@ fn aiur_fn_306(
             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_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+            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 __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -28491,11 +28591,11 @@ fn aiur_fn_306(
             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_306] = { let __args: [G; IN_306] = [__v_12, __v_22, __v_48]; 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_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 __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_306] = [__v_51];
-            record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_310] = [__v_51];
+            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28510,36 +28610,36 @@ fn aiur_fn_306(
   })
 }
 
-const INPUT_SIZE_307: usize = 2;
-const IN_307: usize = 2;
-const OUT_307: usize = 1;
-fn aiur_fn_307(
-  inp: [G; IN_307],
+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_307], ExecError> {
+) -> Result<[G; OUT_311], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+    let __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 __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_307] = [__v_3];
-    record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_311] = [__v_3];
+    record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_308: usize = 16;
-const IN_308: usize = 16;
-const OUT_308: usize = 9;
-fn aiur_fn_308(
-  inp: [G; IN_308],
+const INPUT_SIZE_312: usize = 16;
+const IN_312: usize = 16;
+const OUT_312: usize = 9;
+fn aiur_fn_312(
+  inp: [G; IN_312],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_308], ExecError> {
+) -> Result<[G; OUT_312], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28609,21 +28709,21 @@ fn aiur_fn_308(
     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_308] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_309: usize = 3;
-const IN_309: usize = 3;
-const OUT_309: usize = 2;
-fn aiur_fn_309(
-  inp: [G; IN_309],
+const INPUT_SIZE_313: usize = 3;
+const IN_313: usize = 3;
+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_309], 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];
@@ -28657,8 +28757,8 @@ fn aiur_fn_309(
             let __v_23: G = G::from_u64(1);
             let __v_24: G = G::from_u64(1);
             let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_309] = [__v_25, __v_2];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_313] = [__v_25, __v_2];
+            record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -28666,8 +28766,8 @@ fn aiur_fn_309(
             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_309] = [__v_25, __v_26];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_313] = [__v_25, __v_26];
+            record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28692,8 +28792,8 @@ fn aiur_fn_309(
             match __v_2.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_309] = [__v_0, __v_23];
-                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_313] = [__v_0, __v_23];
+                record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -28705,7 +28805,7 @@ fn aiur_fn_309(
                 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_308] = { let __args: [G; IN_308] = [__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[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_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 __v_31: G = __r_arr[0];
                 let __v_32: G = __r_arr[1];
                 let __v_33: G = __r_arr[2];
@@ -28718,19 +28818,19 @@ fn aiur_fn_309(
                 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_309] = { let __args: [G; IN_309] = [__v_12, __v_42, __v_39]; 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_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 __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_309] = [__v_46, __v_44];
-                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_313] = [__v_46, __v_44];
+                record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__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[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_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 __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -28747,7 +28847,7 @@ fn aiur_fn_309(
             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_308] = { let __args: [G; IN_308] = [__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[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_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 __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -28758,13 +28858,13 @@ fn aiur_fn_309(
             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_309] = { let __args: [G; IN_309] = [__v_12, __v_22, __v_48]; 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_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 __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_309] = [__v_52, __v_50];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_313] = [__v_52, __v_50];
+            record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -28779,15 +28879,15 @@ fn aiur_fn_309(
   })
 }
 
-const INPUT_SIZE_310: usize = 1;
-const IN_310: usize = 1;
-const OUT_310: usize = 1;
-fn aiur_fn_310(
-  inp: [G; IN_310],
+const INPUT_SIZE_314: usize = 1;
+const IN_314: usize = 1;
+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_310], ExecError> {
+) -> Result<[G; OUT_314], 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 };
@@ -28806,12 +28906,12 @@ fn aiur_fn_310(
         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_310] = [__v_13];
-        record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_314] = [__v_13];
+        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_10]; 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_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 __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];
@@ -28833,8 +28933,8 @@ fn aiur_fn_310(
                 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_310] = [__v_25];
-                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_314] = [__v_25];
+                record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -28843,8 +28943,8 @@ fn aiur_fn_310(
                 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_310] = [__v_27];
-                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_314] = [__v_27];
+                record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -28855,8 +28955,8 @@ fn aiur_fn_310(
           _ => {
             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_310] = [__v_23];
-            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_314] = [__v_23];
+            record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -28868,20 +28968,20 @@ 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_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_311], 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 __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+    let __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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -28889,15 +28989,15 @@ fn aiur_fn_311(
         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_311] = [__v_7];
-        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_315] = [__v_7];
+        record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_311] = [__v_5];
-        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_315] = [__v_5];
+        record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -28907,19 +29007,19 @@ fn aiur_fn_311(
   })
 }
 
-const INPUT_SIZE_312: usize = 2;
-const IN_312: usize = 2;
-const OUT_312: usize = 1;
-fn aiur_fn_312(
-  inp: [G; IN_312],
+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_312], 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_311] = { let __args: [G; IN_311] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
+    let __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_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];
@@ -28935,29 +29035,29 @@ fn aiur_fn_312(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_312] = [__v_13];
-        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_316] = [__v_13];
+        record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_312] = [__v_13];
-        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_316] = [__v_13];
+        record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_313: usize = 1;
-const IN_313: usize = 1;
-const OUT_313: usize = 1;
-fn aiur_fn_313(
-  inp: [G; IN_313],
+const INPUT_SIZE_317: usize = 1;
+const IN_317: usize = 1;
+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_313], ExecError> {
+) -> Result<[G; OUT_317], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -28973,23 +29073,23 @@ fn aiur_fn_313(
     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_311] = { let __args: [G; IN_311] = [__v_0, __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_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 __v_14: G = __r_arr[0];
-    let __ret: [G; OUT_313] = [__v_14];
-    record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_317] = [__v_14];
+    record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_314: usize = 2;
-const IN_314: usize = 2;
-const OUT_314: usize = 2;
-fn aiur_fn_314(
-  inp: [G; IN_314],
+const INPUT_SIZE_318: usize = 2;
+const IN_318: usize = 2;
+const OUT_318: usize = 2;
+fn aiur_fn_318(
+  inp: [G; IN_318],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_314], 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];
@@ -28997,8 +29097,8 @@ fn aiur_fn_314(
     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_314] = [__v_0, __v_1];
-        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_318] = [__v_0, __v_1];
+        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -29006,11 +29106,11 @@ fn aiur_fn_314(
         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_314] = { let __args: [G; IN_314] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+        let __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 __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_314] = [__v_8, __v_9];
-        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_318] = [__v_8, __v_9];
+        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29020,40 +29120,40 @@ fn aiur_fn_314(
   })
 }
 
-const INPUT_SIZE_315: usize = 1;
-const IN_315: usize = 1;
-const OUT_315: usize = 3;
-fn aiur_fn_315(
-  inp: [G; IN_315],
+const INPUT_SIZE_319: usize = 1;
+const IN_319: usize = 1;
+const OUT_319: usize = 3;
+fn aiur_fn_319(
+  inp: [G; IN_319],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_315], ExecError> {
+) -> Result<[G; OUT_319], 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_314] = { let __args: [G; IN_314] = [__v_0, __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_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 __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_314] = { let __args: [G; IN_314] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __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 __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_315] = [__v_2, __v_5, __v_6];
-    record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_319] = [__v_2, __v_5, __v_6];
+    record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_316: usize = 16;
-const IN_316: usize = 16;
-const OUT_316: usize = 16;
-fn aiur_fn_316(
-  inp: [G; IN_316],
+const INPUT_SIZE_320: usize = 16;
+const IN_320: usize = 16;
+const OUT_320: usize = 16;
+fn aiur_fn_320(
+  inp: [G; IN_320],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_316], 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];
@@ -29184,7 +29284,7 @@ fn aiur_fn_316(
     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_315] = { let __args: [G; IN_315] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_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 __v_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -29195,19 +29295,19 @@ fn aiur_fn_316(
     let __v_136: G = G::from_u64(0);
     let __v_137: G = if unconstrained { Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record) };
     let __v_138: G = G::from_u64(256);
-    let __v_139: G = (__v_138 * __v_135);
-    let __v_140: G = G::from_u64(65536);
-    let __v_141: G = (__v_140 * __v_137);
-    let __v_142: G = (__v_139 + __v_141);
-    let __v_143: G = (__v_133 + __v_142);
-    if (__v_16 != __v_143) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_143.as_canonical_u64() });
-    }
-    let __v_144: G = G::from_u64(256);
+    let __v_139: G = (__v_138 * __v_137);
+    let __v_140: G = (__v_135 + __v_139);
+    let __v_141: G = (__v_19 + __v_140);
+    let __v_142: G = G::from_u64(256);
+    let __v_143: G = (__v_142 * __v_135);
+    let __v_144: G = G::from_u64(65536);
     let __v_145: G = (__v_144 * __v_137);
-    let __v_146: G = (__v_135 + __v_145);
-    let __v_147: G = (__v_19 + __v_146);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_147]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_146: G = (__v_143 + __v_145);
+    let __v_147: G = (__v_133 + __v_146);
+    if (__v_16 != __v_147) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_148: G = __r_arr[0];
     let __v_149: G = __r_arr[1];
     let __v_150: G = __r_arr[2];
@@ -29218,19 +29318,19 @@ fn aiur_fn_316(
     let __v_155: G = G::from_u64(0);
     let __v_156: G = if unconstrained { Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record) };
     let __v_157: G = G::from_u64(256);
-    let __v_158: G = (__v_157 * __v_154);
-    let __v_159: G = G::from_u64(65536);
-    let __v_160: G = (__v_159 * __v_156);
-    let __v_161: G = (__v_158 + __v_160);
-    let __v_162: G = (__v_152 + __v_161);
-    if (__v_147 != __v_162) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_147.as_canonical_u64(), rhs: __v_162.as_canonical_u64() });
-    }
-    let __v_163: G = G::from_u64(256);
+    let __v_158: G = (__v_157 * __v_156);
+    let __v_159: G = (__v_154 + __v_158);
+    let __v_160: G = (__v_24 + __v_159);
+    let __v_161: G = G::from_u64(256);
+    let __v_162: G = (__v_161 * __v_154);
+    let __v_163: G = G::from_u64(65536);
     let __v_164: G = (__v_163 * __v_156);
-    let __v_165: G = (__v_154 + __v_164);
-    let __v_166: G = (__v_24 + __v_165);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_166]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_165: G = (__v_162 + __v_164);
+    let __v_166: G = (__v_152 + __v_165);
+    if (__v_141 != __v_166) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_167: G = __r_arr[0];
     let __v_168: G = __r_arr[1];
     let __v_169: G = __r_arr[2];
@@ -29241,19 +29341,19 @@ fn aiur_fn_316(
     let __v_174: G = G::from_u64(0);
     let __v_175: G = if unconstrained { Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record) };
     let __v_176: G = G::from_u64(256);
-    let __v_177: G = (__v_176 * __v_173);
-    let __v_178: G = G::from_u64(65536);
-    let __v_179: G = (__v_178 * __v_175);
-    let __v_180: G = (__v_177 + __v_179);
-    let __v_181: G = (__v_171 + __v_180);
-    if (__v_166 != __v_181) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_181.as_canonical_u64() });
-    }
-    let __v_182: G = G::from_u64(256);
+    let __v_177: G = (__v_176 * __v_175);
+    let __v_178: G = (__v_173 + __v_177);
+    let __v_179: G = (__v_31 + __v_178);
+    let __v_180: G = G::from_u64(256);
+    let __v_181: G = (__v_180 * __v_173);
+    let __v_182: G = G::from_u64(65536);
     let __v_183: G = (__v_182 * __v_175);
-    let __v_184: G = (__v_173 + __v_183);
-    let __v_185: G = (__v_31 + __v_184);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_185]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_184: G = (__v_181 + __v_183);
+    let __v_185: G = (__v_171 + __v_184);
+    if (__v_160 != __v_185) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_186: G = __r_arr[0];
     let __v_187: G = __r_arr[1];
     let __v_188: G = __r_arr[2];
@@ -29264,19 +29364,19 @@ fn aiur_fn_316(
     let __v_193: G = G::from_u64(0);
     let __v_194: G = if unconstrained { Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record) };
     let __v_195: G = G::from_u64(256);
-    let __v_196: G = (__v_195 * __v_192);
-    let __v_197: G = G::from_u64(65536);
-    let __v_198: G = (__v_197 * __v_194);
-    let __v_199: G = (__v_196 + __v_198);
-    let __v_200: G = (__v_190 + __v_199);
-    if (__v_185 != __v_200) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_185.as_canonical_u64(), rhs: __v_200.as_canonical_u64() });
-    }
-    let __v_201: G = G::from_u64(256);
+    let __v_196: G = (__v_195 * __v_194);
+    let __v_197: G = (__v_192 + __v_196);
+    let __v_198: G = (__v_40 + __v_197);
+    let __v_199: G = G::from_u64(256);
+    let __v_200: G = (__v_199 * __v_192);
+    let __v_201: G = G::from_u64(65536);
     let __v_202: G = (__v_201 * __v_194);
-    let __v_203: G = (__v_192 + __v_202);
-    let __v_204: G = (__v_40 + __v_203);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_204]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_203: G = (__v_200 + __v_202);
+    let __v_204: G = (__v_190 + __v_203);
+    if (__v_179 != __v_204) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_205: G = __r_arr[0];
     let __v_206: G = __r_arr[1];
     let __v_207: G = __r_arr[2];
@@ -29287,19 +29387,19 @@ fn aiur_fn_316(
     let __v_212: G = G::from_u64(0);
     let __v_213: G = if unconstrained { Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record) };
     let __v_214: G = G::from_u64(256);
-    let __v_215: G = (__v_214 * __v_211);
-    let __v_216: G = G::from_u64(65536);
-    let __v_217: G = (__v_216 * __v_213);
-    let __v_218: G = (__v_215 + __v_217);
-    let __v_219: G = (__v_209 + __v_218);
-    if (__v_204 != __v_219) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_204.as_canonical_u64(), rhs: __v_219.as_canonical_u64() });
-    }
-    let __v_220: G = G::from_u64(256);
+    let __v_215: G = (__v_214 * __v_213);
+    let __v_216: G = (__v_211 + __v_215);
+    let __v_217: G = (__v_51 + __v_216);
+    let __v_218: G = G::from_u64(256);
+    let __v_219: G = (__v_218 * __v_211);
+    let __v_220: G = G::from_u64(65536);
     let __v_221: G = (__v_220 * __v_213);
-    let __v_222: G = (__v_211 + __v_221);
-    let __v_223: G = (__v_51 + __v_222);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_223]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_222: G = (__v_219 + __v_221);
+    let __v_223: G = (__v_209 + __v_222);
+    if (__v_198 != __v_223) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_224: G = __r_arr[0];
     let __v_225: G = __r_arr[1];
     let __v_226: G = __r_arr[2];
@@ -29310,19 +29410,19 @@ fn aiur_fn_316(
     let __v_231: G = G::from_u64(0);
     let __v_232: G = if unconstrained { Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record) };
     let __v_233: G = G::from_u64(256);
-    let __v_234: G = (__v_233 * __v_230);
-    let __v_235: G = G::from_u64(65536);
-    let __v_236: G = (__v_235 * __v_232);
-    let __v_237: G = (__v_234 + __v_236);
-    let __v_238: G = (__v_228 + __v_237);
-    if (__v_223 != __v_238) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_238.as_canonical_u64() });
-    }
-    let __v_239: G = G::from_u64(256);
+    let __v_234: G = (__v_233 * __v_232);
+    let __v_235: G = (__v_230 + __v_234);
+    let __v_236: G = (__v_64 + __v_235);
+    let __v_237: G = G::from_u64(256);
+    let __v_238: G = (__v_237 * __v_230);
+    let __v_239: G = G::from_u64(65536);
     let __v_240: G = (__v_239 * __v_232);
-    let __v_241: G = (__v_230 + __v_240);
-    let __v_242: G = (__v_64 + __v_241);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_242]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_241: G = (__v_238 + __v_240);
+    let __v_242: G = (__v_228 + __v_241);
+    if (__v_217 != __v_242) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_243: G = __r_arr[0];
     let __v_244: G = __r_arr[1];
     let __v_245: G = __r_arr[2];
@@ -29333,19 +29433,19 @@ fn aiur_fn_316(
     let __v_250: G = G::from_u64(0);
     let __v_251: G = if unconstrained { Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record) };
     let __v_252: G = G::from_u64(256);
-    let __v_253: G = (__v_252 * __v_249);
-    let __v_254: G = G::from_u64(65536);
-    let __v_255: G = (__v_254 * __v_251);
-    let __v_256: G = (__v_253 + __v_255);
-    let __v_257: G = (__v_247 + __v_256);
-    if (__v_242 != __v_257) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_257.as_canonical_u64() });
-    }
-    let __v_258: G = G::from_u64(256);
+    let __v_253: G = (__v_252 * __v_251);
+    let __v_254: G = (__v_249 + __v_253);
+    let __v_255: G = (__v_79 + __v_254);
+    let __v_256: G = G::from_u64(256);
+    let __v_257: G = (__v_256 * __v_249);
+    let __v_258: G = G::from_u64(65536);
     let __v_259: G = (__v_258 * __v_251);
-    let __v_260: G = (__v_249 + __v_259);
-    let __v_261: G = (__v_79 + __v_260);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_261]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_260: G = (__v_257 + __v_259);
+    let __v_261: G = (__v_247 + __v_260);
+    if (__v_236 != __v_261) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_262: G = __r_arr[0];
     let __v_263: G = __r_arr[1];
     let __v_264: G = __r_arr[2];
@@ -29356,19 +29456,19 @@ fn aiur_fn_316(
     let __v_269: G = G::from_u64(0);
     let __v_270: G = if unconstrained { Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record) };
     let __v_271: G = G::from_u64(256);
-    let __v_272: G = (__v_271 * __v_268);
-    let __v_273: G = G::from_u64(65536);
-    let __v_274: G = (__v_273 * __v_270);
-    let __v_275: G = (__v_272 + __v_274);
-    let __v_276: G = (__v_266 + __v_275);
-    if (__v_261 != __v_276) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_276.as_canonical_u64() });
-    }
-    let __v_277: G = G::from_u64(256);
+    let __v_272: G = (__v_271 * __v_270);
+    let __v_273: G = (__v_268 + __v_272);
+    let __v_274: G = (__v_92 + __v_273);
+    let __v_275: G = G::from_u64(256);
+    let __v_276: G = (__v_275 * __v_268);
+    let __v_277: G = G::from_u64(65536);
     let __v_278: G = (__v_277 * __v_270);
-    let __v_279: G = (__v_268 + __v_278);
-    let __v_280: G = (__v_92 + __v_279);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_280]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_279: G = (__v_276 + __v_278);
+    let __v_280: G = (__v_266 + __v_279);
+    if (__v_255 != __v_280) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_281: G = __r_arr[0];
     let __v_282: G = __r_arr[1];
     let __v_283: G = __r_arr[2];
@@ -29379,19 +29479,19 @@ fn aiur_fn_316(
     let __v_288: G = G::from_u64(0);
     let __v_289: G = if unconstrained { Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record) };
     let __v_290: G = G::from_u64(256);
-    let __v_291: G = (__v_290 * __v_287);
-    let __v_292: G = G::from_u64(65536);
-    let __v_293: G = (__v_292 * __v_289);
-    let __v_294: G = (__v_291 + __v_293);
-    let __v_295: G = (__v_285 + __v_294);
-    if (__v_280 != __v_295) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_280.as_canonical_u64(), rhs: __v_295.as_canonical_u64() });
-    }
-    let __v_296: G = G::from_u64(256);
+    let __v_291: G = (__v_290 * __v_289);
+    let __v_292: G = (__v_287 + __v_291);
+    let __v_293: G = (__v_103 + __v_292);
+    let __v_294: G = G::from_u64(256);
+    let __v_295: G = (__v_294 * __v_287);
+    let __v_296: G = G::from_u64(65536);
     let __v_297: G = (__v_296 * __v_289);
-    let __v_298: G = (__v_287 + __v_297);
-    let __v_299: G = (__v_103 + __v_298);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_299]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_298: G = (__v_295 + __v_297);
+    let __v_299: G = (__v_285 + __v_298);
+    if (__v_274 != __v_299) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_300: G = __r_arr[0];
     let __v_301: G = __r_arr[1];
     let __v_302: G = __r_arr[2];
@@ -29402,19 +29502,19 @@ fn aiur_fn_316(
     let __v_307: G = G::from_u64(0);
     let __v_308: G = if unconstrained { Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record) };
     let __v_309: G = G::from_u64(256);
-    let __v_310: G = (__v_309 * __v_306);
-    let __v_311: G = G::from_u64(65536);
-    let __v_312: G = (__v_311 * __v_308);
-    let __v_313: G = (__v_310 + __v_312);
-    let __v_314: G = (__v_304 + __v_313);
-    if (__v_299 != __v_314) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_299.as_canonical_u64(), rhs: __v_314.as_canonical_u64() });
-    }
-    let __v_315: G = G::from_u64(256);
+    let __v_310: G = (__v_309 * __v_308);
+    let __v_311: G = (__v_306 + __v_310);
+    let __v_312: G = (__v_112 + __v_311);
+    let __v_313: G = G::from_u64(256);
+    let __v_314: G = (__v_313 * __v_306);
+    let __v_315: G = G::from_u64(65536);
     let __v_316: G = (__v_315 * __v_308);
-    let __v_317: G = (__v_306 + __v_316);
-    let __v_318: G = (__v_112 + __v_317);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_318]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_317: G = (__v_314 + __v_316);
+    let __v_318: G = (__v_304 + __v_317);
+    if (__v_293 != __v_318) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_319: G = __r_arr[0];
     let __v_320: G = __r_arr[1];
     let __v_321: G = __r_arr[2];
@@ -29425,19 +29525,19 @@ fn aiur_fn_316(
     let __v_326: G = G::from_u64(0);
     let __v_327: G = if unconstrained { Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record) };
     let __v_328: G = G::from_u64(256);
-    let __v_329: G = (__v_328 * __v_325);
-    let __v_330: G = G::from_u64(65536);
-    let __v_331: G = (__v_330 * __v_327);
-    let __v_332: G = (__v_329 + __v_331);
-    let __v_333: G = (__v_323 + __v_332);
-    if (__v_318 != __v_333) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_318.as_canonical_u64(), rhs: __v_333.as_canonical_u64() });
-    }
-    let __v_334: G = G::from_u64(256);
+    let __v_329: G = (__v_328 * __v_327);
+    let __v_330: G = (__v_325 + __v_329);
+    let __v_331: G = (__v_119 + __v_330);
+    let __v_332: G = G::from_u64(256);
+    let __v_333: G = (__v_332 * __v_325);
+    let __v_334: G = G::from_u64(65536);
     let __v_335: G = (__v_334 * __v_327);
-    let __v_336: G = (__v_325 + __v_335);
-    let __v_337: G = (__v_119 + __v_336);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_337]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_336: G = (__v_333 + __v_335);
+    let __v_337: G = (__v_323 + __v_336);
+    if (__v_312 != __v_337) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_338: G = __r_arr[0];
     let __v_339: G = __r_arr[1];
     let __v_340: G = __r_arr[2];
@@ -29448,19 +29548,19 @@ fn aiur_fn_316(
     let __v_345: G = G::from_u64(0);
     let __v_346: G = if unconstrained { Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record) };
     let __v_347: G = G::from_u64(256);
-    let __v_348: G = (__v_347 * __v_344);
-    let __v_349: G = G::from_u64(65536);
-    let __v_350: G = (__v_349 * __v_346);
-    let __v_351: G = (__v_348 + __v_350);
-    let __v_352: G = (__v_342 + __v_351);
-    if (__v_337 != __v_352) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_337.as_canonical_u64(), rhs: __v_352.as_canonical_u64() });
-    }
-    let __v_353: G = G::from_u64(256);
+    let __v_348: G = (__v_347 * __v_346);
+    let __v_349: G = (__v_344 + __v_348);
+    let __v_350: G = (__v_124 + __v_349);
+    let __v_351: G = G::from_u64(256);
+    let __v_352: G = (__v_351 * __v_344);
+    let __v_353: G = G::from_u64(65536);
     let __v_354: G = (__v_353 * __v_346);
-    let __v_355: G = (__v_344 + __v_354);
-    let __v_356: G = (__v_124 + __v_355);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_356]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_355: G = (__v_352 + __v_354);
+    let __v_356: G = (__v_342 + __v_355);
+    if (__v_331 != __v_356) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_357: G = __r_arr[0];
     let __v_358: G = __r_arr[1];
     let __v_359: G = __r_arr[2];
@@ -29471,19 +29571,19 @@ fn aiur_fn_316(
     let __v_364: G = G::from_u64(0);
     let __v_365: G = if unconstrained { Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record) };
     let __v_366: G = G::from_u64(256);
-    let __v_367: G = (__v_366 * __v_363);
-    let __v_368: G = G::from_u64(65536);
-    let __v_369: G = (__v_368 * __v_365);
-    let __v_370: G = (__v_367 + __v_369);
-    let __v_371: G = (__v_361 + __v_370);
-    if (__v_356 != __v_371) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_371.as_canonical_u64() });
-    }
-    let __v_372: G = G::from_u64(256);
+    let __v_367: G = (__v_366 * __v_365);
+    let __v_368: G = (__v_363 + __v_367);
+    let __v_369: G = (__v_127 + __v_368);
+    let __v_370: G = G::from_u64(256);
+    let __v_371: G = (__v_370 * __v_363);
+    let __v_372: G = G::from_u64(65536);
     let __v_373: G = (__v_372 * __v_365);
-    let __v_374: G = (__v_363 + __v_373);
-    let __v_375: G = (__v_127 + __v_374);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_375]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_374: G = (__v_371 + __v_373);
+    let __v_375: G = (__v_361 + __v_374);
+    if (__v_350 != __v_375) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_376: G = __r_arr[0];
     let __v_377: G = __r_arr[1];
     let __v_378: G = __r_arr[2];
@@ -29494,19 +29594,19 @@ fn aiur_fn_316(
     let __v_383: G = G::from_u64(0);
     let __v_384: G = if unconstrained { Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record) };
     let __v_385: G = G::from_u64(256);
-    let __v_386: G = (__v_385 * __v_382);
-    let __v_387: G = G::from_u64(65536);
-    let __v_388: G = (__v_387 * __v_384);
-    let __v_389: G = (__v_386 + __v_388);
-    let __v_390: G = (__v_380 + __v_389);
-    if (__v_375 != __v_390) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_375.as_canonical_u64(), rhs: __v_390.as_canonical_u64() });
-    }
-    let __v_391: G = G::from_u64(256);
+    let __v_386: G = (__v_385 * __v_384);
+    let __v_387: G = (__v_382 + __v_386);
+    let __v_388: G = (__v_128 + __v_387);
+    let __v_389: G = G::from_u64(256);
+    let __v_390: G = (__v_389 * __v_382);
+    let __v_391: G = G::from_u64(65536);
     let __v_392: G = (__v_391 * __v_384);
-    let __v_393: G = (__v_382 + __v_392);
-    let __v_394: G = (__v_128 + __v_393);
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_394]; let __cu = true; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { 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_393: G = (__v_390 + __v_392);
+    let __v_394: G = (__v_380 + __v_393);
+    if (__v_369 != __v_394) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64() });
+    }
+    let __r_arr: [G; OUT_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 __v_395: G = __r_arr[0];
     let __v_396: G = __r_arr[1];
     let __v_397: G = __r_arr[2];
@@ -29517,32 +29617,32 @@ fn aiur_fn_316(
     let __v_402: G = G::from_u64(0);
     let __v_403: G = if unconstrained { Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record) };
     let __v_404: G = G::from_u64(256);
-    let __v_405: G = (__v_404 * __v_401);
-    let __v_406: G = G::from_u64(65536);
-    let __v_407: G = (__v_406 * __v_403);
-    let __v_408: G = (__v_405 + __v_407);
-    let __v_409: G = (__v_399 + __v_408);
-    if (__v_394 != __v_409) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_394.as_canonical_u64(), rhs: __v_409.as_canonical_u64() });
-    }
-    let __v_410: G = G::from_u64(256);
-    let __v_411: G = (__v_410 * __v_403);
-    let __v_412: G = (__v_401 + __v_411);
-    let __ret: [G; OUT_316] = [__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_412];
-    record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_405: G = (__v_404 * __v_403);
+    let __v_406: G = (__v_401 + __v_405);
+    let __v_407: G = G::from_u64(256);
+    let __v_408: G = (__v_407 * __v_401);
+    let __v_409: G = G::from_u64(65536);
+    let __v_410: G = (__v_409 * __v_403);
+    let __v_411: G = (__v_408 + __v_410);
+    let __v_412: G = (__v_399 + __v_411);
+    if (__v_388 != __v_412) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64() });
+    }
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_317: usize = 2;
-const IN_317: usize = 2;
-const OUT_317: usize = 1;
-fn aiur_fn_317(
-  inp: [G; IN_317],
+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_317], 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];
@@ -29550,23 +29650,23 @@ fn aiur_fn_317(
     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_318] = { let __args: [G; IN_318] = [__v_0, __v_1, __v_4, __v_5]; 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_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 __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_317] = [__v_6];
-    record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_321] = [__v_6];
+    record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_318: usize = 4;
-const IN_318: usize = 4;
-const OUT_318: usize = 1;
-fn aiur_fn_318(
-  inp: [G; IN_318],
+const INPUT_SIZE_322: usize = 4;
+const IN_322: usize = 4;
+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_318], 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];
@@ -29585,8 +29685,8 @@ fn aiur_fn_318(
     let __v_13: G = __loaded[9];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_318] = [__v_2];
-        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_322] = [__v_2];
+        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -29601,18 +29701,18 @@ fn aiur_fn_318(
         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_319] = { let __args: [G; IN_319] = [__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[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 __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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_25, __v_3]; 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_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 __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_2, __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 __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 __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_318] = { let __args: [G; IN_318] = [__v_13, __v_1, __v_27, __v_29]; 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_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 __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_318] = [__v_30];
-        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_322] = [__v_30];
+        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29622,15 +29722,15 @@ fn aiur_fn_318(
   })
 }
 
-const INPUT_SIZE_319: usize = 18;
-const IN_319: usize = 18;
-const OUT_319: usize = 1;
-fn aiur_fn_319(
-  inp: [G; IN_319],
+const INPUT_SIZE_323: usize = 18;
+const IN_323: usize = 18;
+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_319], 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];
@@ -29667,15 +29767,15 @@ fn aiur_fn_319(
         let __v_28: G = __r_arr[0];
         match __v_28.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_319] = [__v_17];
-            record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_323] = [__v_17];
+            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__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[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_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 __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_319] = [__v_29];
-            record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_323] = [__v_29];
+            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -29684,7 +29784,7 @@ fn aiur_fn_319(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__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[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_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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -29701,7 +29801,7 @@ fn aiur_fn_319(
         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_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } };
+        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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -29718,7 +29818,7 @@ fn aiur_fn_319(
         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_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__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, __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 __v_60: G = __r_arr[0];
         let __v_61: G = __r_arr[1];
         let __v_62: G = __r_arr[2];
@@ -29728,12 +29828,12 @@ fn aiur_fn_319(
         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_797] = { let __args: [G; IN_797] = [__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[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_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 __v_69: G = __r_arr[0];
-        let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__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[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 __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 __v_70: G = __r_arr[0];
-        let __ret: [G; OUT_319] = [__v_70];
-        record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_323] = [__v_70];
+        record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29743,22 +29843,22 @@ fn aiur_fn_319(
   })
 }
 
-const INPUT_SIZE_320: usize = 2;
-const IN_320: usize = 2;
-const OUT_320: usize = 1;
-fn aiur_fn_320(
-  inp: [G; IN_320],
+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_320], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_320] = [__v_0];
-        record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_324] = [__v_0];
+        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29774,28 +29874,28 @@ fn aiur_fn_320(
         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_320] = { let __args: [G; IN_320] = [__v_11, __v_13]; 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_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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_320] = [__v_14];
-        record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_324] = [__v_14];
+        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_321: usize = 1;
-const IN_321: usize = 1;
-const OUT_321: usize = 1;
-fn aiur_fn_321(
-  inp: [G; IN_321],
+const INPUT_SIZE_325: usize = 1;
+const IN_325: usize = 1;
+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_321], ExecError> {
+) -> Result<[G; OUT_325], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; 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_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 __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];
@@ -29811,65 +29911,65 @@ fn aiur_fn_321(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_321] = [__v_12];
-        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_325] = [__v_12];
+        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_321] = [__v_12];
-        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_325] = [__v_12];
+        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_322: usize = 2;
-const IN_322: usize = 2;
-const OUT_322: usize = 2;
-fn aiur_fn_322(
-  inp: [G; IN_322],
+const INPUT_SIZE_326: usize = 2;
+const IN_326: usize = 2;
+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_322], 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];
     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_317] = { let __args: [G; IN_317] = [__v_2, __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 __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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_3]; 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_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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5]; 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_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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; 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_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 __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_321] = { let __args: [G; IN_321] = [__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_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 __v_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_322] = [__v_2, __v_3];
-        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_2, __v_3];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; 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_309] = { let __args: [G; IN_309] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_9, __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 __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 __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_322] = [__v_2, __v_3];
-        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_2, __v_3];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29879,75 +29979,75 @@ fn aiur_fn_322(
   })
 }
 
-const INPUT_SIZE_323: usize = 2;
-const IN_323: usize = 2;
-const OUT_323: usize = 1;
-fn aiur_fn_323(
-  inp: [G; IN_323],
+const INPUT_SIZE_327: usize = 2;
+const IN_327: usize = 2;
+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_323], 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];
-    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; 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_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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_323] = [__v_2];
-    record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_327] = [__v_2];
+    record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_324: usize = 2;
-const IN_324: usize = 2;
-const OUT_324: usize = 1;
-fn aiur_fn_324(
-  inp: [G; IN_324],
+const INPUT_SIZE_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_324], 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];
-    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; 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_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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_324] = [__v_3];
-    record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_328] = [__v_3];
+    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_325: usize = 2;
-const IN_325: usize = 2;
-const OUT_325: usize = 1;
-fn aiur_fn_325(
-  inp: [G; IN_325],
+const INPUT_SIZE_329: usize = 2;
+const IN_329: usize = 2;
+const OUT_329: usize = 1;
+fn aiur_fn_329(
+  inp: [G; IN_329],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_325], ExecError> {
+) -> Result<[G; OUT_329], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__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_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 __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_325] = [__v_0];
-        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_329] = [__v_0];
+        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; 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_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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_325] = [__v_4];
-        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_329] = [__v_4];
+        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -29957,19 +30057,19 @@ fn aiur_fn_325(
   })
 }
 
-const INPUT_SIZE_326: usize = 2;
-const IN_326: usize = 2;
-const OUT_326: usize = 1;
-fn aiur_fn_326(
-  inp: [G; IN_326],
+const INPUT_SIZE_330: usize = 2;
+const IN_330: usize = 2;
+const OUT_330: usize = 1;
+fn aiur_fn_330(
+  inp: [G; IN_330],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_326], 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];
-    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__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_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 __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -29986,8 +30086,8 @@ fn aiur_fn_326(
         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_326] = [__v_15];
-        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_15];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30004,30 +30104,30 @@ fn aiur_fn_326(
         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_322] = { let __args: [G; IN_322] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+        let __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 __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
-        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_18]; 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_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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+        let __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 __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_17]; 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_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 __v_22: G = __r_arr[0];
         match __v_22.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_326] = [__v_21];
-            record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_330] = [__v_21];
+            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_21]; 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_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 __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_326] = [__v_23];
-            record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_330] = [__v_23];
+            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30042,15 +30142,15 @@ fn aiur_fn_326(
   })
 }
 
-const INPUT_SIZE_327: usize = 16;
-const IN_327: usize = 16;
-const OUT_327: usize = 8;
-fn aiur_fn_327(
-  inp: [G; IN_327],
+const INPUT_SIZE_331: usize = 16;
+const IN_331: usize = 16;
+const OUT_331: usize = 8;
+fn aiur_fn_331(
+  inp: [G; IN_331],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_327], ExecError> {
+) -> Result<[G; OUT_331], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30076,21 +30176,21 @@ fn aiur_fn_327(
     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_327] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_328: usize = 16;
-const IN_328: usize = 16;
-const OUT_328: usize = 8;
-fn aiur_fn_328(
-  inp: [G; IN_328],
+const INPUT_SIZE_332: usize = 16;
+const IN_332: usize = 16;
+const OUT_332: usize = 8;
+fn aiur_fn_332(
+  inp: [G; IN_332],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_328], ExecError> {
+) -> Result<[G; OUT_332], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30116,21 +30216,21 @@ fn aiur_fn_328(
     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_328] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_329: usize = 16;
-const IN_329: usize = 16;
-const OUT_329: usize = 8;
-fn aiur_fn_329(
-  inp: [G; IN_329],
+const INPUT_SIZE_333: usize = 16;
+const IN_333: usize = 16;
+const OUT_333: usize = 8;
+fn aiur_fn_333(
+  inp: [G; IN_333],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_329], 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];
@@ -30156,21 +30256,21 @@ fn aiur_fn_329(
     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_329] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-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_334: usize = 2;
+const IN_334: usize = 2;
+const OUT_334: usize = 1;
+fn aiur_fn_334(
+  inp: [G; IN_334],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_330], 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];
@@ -30190,8 +30290,8 @@ fn aiur_fn_330(
         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_330] = [__v_14];
-        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_334] = [__v_14];
+        record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30211,13 +30311,13 @@ fn aiur_fn_330(
             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_330] = [__v_24];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_334] = [__v_24];
+            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
+            let __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 __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -30226,11 +30326,11 @@ fn aiur_fn_330(
             let __v_28: G = __r_arr[5];
             let __v_29: G = __r_arr[6];
             let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+            let __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 __v_31: G = __r_arr[0];
             let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_330] = [__v_32];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_334] = [__v_32];
+            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30245,15 +30345,15 @@ fn aiur_fn_330(
   })
 }
 
-const INPUT_SIZE_331: usize = 2;
-const IN_331: usize = 2;
-const OUT_331: usize = 1;
-fn aiur_fn_331(
-  inp: [G; IN_331],
+const INPUT_SIZE_335: usize = 2;
+const IN_335: usize = 2;
+const OUT_335: usize = 1;
+fn aiur_fn_335(
+  inp: [G; IN_335],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_331], 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];
@@ -30270,8 +30370,8 @@ fn aiur_fn_331(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_331] = [__v_1];
-        record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_335] = [__v_1];
+        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30288,13 +30388,13 @@ fn aiur_fn_331(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_331] = [__v_0];
-            record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_335] = [__v_0];
+            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
+            let __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 __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -30303,11 +30403,11 @@ fn aiur_fn_331(
             let __v_28: G = __r_arr[5];
             let __v_29: G = __r_arr[6];
             let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+            let __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 __v_31: G = __r_arr[0];
             let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_331] = [__v_32];
-            record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_335] = [__v_32];
+            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30322,15 +30422,15 @@ fn aiur_fn_331(
   })
 }
 
-const INPUT_SIZE_332: usize = 2;
-const IN_332: usize = 2;
-const OUT_332: usize = 1;
-fn aiur_fn_332(
-  inp: [G; IN_332],
+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_332], 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];
@@ -30347,8 +30447,8 @@ fn aiur_fn_332(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_332] = [__v_1];
-        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_336] = [__v_1];
+        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -30365,13 +30465,13 @@ fn aiur_fn_332(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_332] = [__v_0];
-            record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_336] = [__v_0];
+            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__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[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_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 __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -30380,11 +30480,11 @@ fn aiur_fn_332(
             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_332] = { let __args: [G; IN_332] = [__v_11, __v_21]; 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_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 __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_332] = [__v_32];
-            record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_336] = [__v_32];
+            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30399,15 +30499,15 @@ fn aiur_fn_332(
   })
 }
 
-const INPUT_SIZE_333: usize = 2;
-const IN_333: usize = 2;
-const OUT_333: usize = 1;
-fn aiur_fn_333(
-  inp: [G; IN_333],
+const INPUT_SIZE_337: usize = 2;
+const IN_337: usize = 2;
+const OUT_337: usize = 1;
+fn aiur_fn_337(
+  inp: [G; IN_337],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_333], 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];
@@ -30424,25 +30524,25 @@ fn aiur_fn_333(
     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_326] = { let __args: [G; IN_326] = [__v_14, __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_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 __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_15]; 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_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 __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_333] = [__v_16];
-    record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_337] = [__v_16];
+    record.function_queries[337].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_338: usize = 2;
+const IN_338: usize = 2;
+const OUT_338: usize = 1;
+fn aiur_fn_338(
+  inp: [G; IN_338],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_334], 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];
@@ -30459,25 +30559,25 @@ fn aiur_fn_334(
     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_326] = { let __args: [G; IN_326] = [__v_14, __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_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 __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_15]; 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_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 __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_334] = [__v_16];
-    record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_338] = [__v_16];
+    record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_335: usize = 3;
-const IN_335: usize = 3;
-const OUT_335: usize = 2;
-fn aiur_fn_335(
-  inp: [G; IN_335],
+const INPUT_SIZE_339: usize = 3;
+const IN_339: usize = 3;
+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_335], 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];
@@ -30490,28 +30590,28 @@ fn aiur_fn_335(
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_335] = [__v_6, __v_7];
-        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_339] = [__v_6, __v_7];
+        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_4]; 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_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 __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_335] = [__v_7, __v_2];
-            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_339] = [__v_7, __v_2];
+            record.function_queries[339].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_335] = { let __args: [G; IN_335] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __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 __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_335] = [__v_9, __v_10];
-            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_339] = [__v_9, __v_10];
+            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30526,15 +30626,15 @@ fn aiur_fn_335(
   })
 }
 
-const INPUT_SIZE_336: usize = 3;
-const IN_336: usize = 3;
-const OUT_336: usize = 1;
-fn aiur_fn_336(
-  inp: [G; IN_336],
+const INPUT_SIZE_340: usize = 3;
+const IN_340: usize = 3;
+const OUT_340: usize = 1;
+fn aiur_fn_340(
+  inp: [G; IN_340],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_336], 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];
@@ -30558,16 +30658,16 @@ fn aiur_fn_336(
         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_336] = [__v_18];
-        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_340] = [__v_18];
+        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0]; 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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14]; 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_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 __v_15: G = __r_arr[0];
         let __v_16: G = G::from_u64(2);
         let __v_17: G = G::from_u64(1);
@@ -30578,8 +30678,8 @@ fn aiur_fn_336(
         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_336] = [__v_24];
-        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_340] = [__v_24];
+        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30589,15 +30689,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_341: usize = 2;
+const IN_341: usize = 2;
+const OUT_341: usize = 1;
+fn aiur_fn_341(
+  inp: [G; IN_341],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_337], 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];
@@ -30610,67 +30710,67 @@ fn aiur_fn_337(
       7u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+            let __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_6: G = __r_arr[0];
             let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_1, __v_7]; 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_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 __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            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_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_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_10, __v_1, __v_11]; 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_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 __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_336] = { let __args: [G; IN_336] = [__v_4, __v_9, __v_13]; 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_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 __v_14: G = __r_arr[0];
-                    let __ret: [G; OUT_337] = [__v_14];
-                    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_341] = [__v_14];
+                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __ret: [G; OUT_337] = [__v_0];
-                    record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_341] = [__v_0];
+                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_337] = [__v_0];
-                record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_341] = [__v_0];
+                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_337] = [__v_0];
-            record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_341] = [__v_0];
+            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_337] = [__v_0];
-        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_341] = [__v_0];
+        record.function_queries[341].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 = 2;
-fn aiur_fn_338(
-  inp: [G; IN_338],
+const INPUT_SIZE_342: usize = 2;
+const IN_342: usize = 2;
+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_338], 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];
@@ -30684,8 +30784,8 @@ fn aiur_fn_338(
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_338] = [__v_6, __v_4];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_342] = [__v_6, __v_4];
+            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30693,18 +30793,18 @@ fn aiur_fn_338(
             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_338] = [__v_6, __v_9];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_342] = [__v_6, __v_9];
+            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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_6: 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_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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; 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_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 __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
@@ -30712,8 +30812,8 @@ fn aiur_fn_338(
             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_338] = [__v_9, __v_12];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_342] = [__v_9, __v_12];
+            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -30721,8 +30821,8 @@ fn aiur_fn_338(
             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_338] = [__v_9, __v_12];
-            record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_342] = [__v_9, __v_12];
+            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30731,11 +30831,11 @@ fn aiur_fn_338(
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_4, __v_1]; 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_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 __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __ret: [G; OUT_338] = [__v_6, __v_7];
-        record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_342] = [__v_6, __v_7];
+        record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -30743,23 +30843,23 @@ fn aiur_fn_338(
         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_338] = [__v_6, __v_9];
-        record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_342] = [__v_6, __v_9];
+        record.function_queries[342].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_343: usize = 3;
+const IN_343: usize = 3;
+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_339], 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];
@@ -30771,24 +30871,24 @@ fn aiur_fn_339(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_4]; 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_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 __v_7: 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_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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_7, __v_8]; 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_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 __v_9: G = __r_arr[0];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            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_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 __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_305] = { let __args: [G; IN_305] = [__v_11]; 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_309] = { let __args: [G; IN_309] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_339] = [__v_12, __v_13];
-                record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_343] = [__v_12, __v_13];
+                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -30796,8 +30896,8 @@ fn aiur_fn_339(
                 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_339] = [__v_12, __v_15];
-                record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_343] = [__v_12, __v_15];
+                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -30807,8 +30907,8 @@ fn aiur_fn_339(
             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_339] = [__v_10, __v_13];
-            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_343] = [__v_10, __v_13];
+            record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -30821,217 +30921,217 @@ fn aiur_fn_339(
         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_339] = [__v_7, __v_10];
-        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_343] = [__v_7, __v_10];
+        record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_340: usize = 1;
-const IN_340: usize = 1;
-const OUT_340: usize = 1;
-fn aiur_fn_340(
-  inp: [G; IN_340],
+const INPUT_SIZE_344: usize = 1;
+const IN_344: usize = 1;
+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_340], ExecError> {
+) -> Result<[G; OUT_344], 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_340] = [__v_4];
-    record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_344] = [__v_4];
+    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_341: usize = 1;
-const IN_341: usize = 1;
-const OUT_341: usize = 1;
-fn aiur_fn_341(
-  inp: [G; IN_341],
+const INPUT_SIZE_345: usize = 1;
+const IN_345: usize = 1;
+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_341], ExecError> {
+) -> Result<[G; OUT_345], 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_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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; 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_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 __v_2: 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_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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __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_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 __v_4: 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_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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; 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_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 __v_6: 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_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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; 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_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 __v_8: 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_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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; 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_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 __v_10: 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_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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; 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_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 __v_12: 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_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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_13]; 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_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 __v_14: 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_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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __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 __v_16: 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_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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_17]; 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_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 __v_18: 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_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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_19]; 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_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 __v_20: 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_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_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_21]; 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_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 __v_22: 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_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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_23]; 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_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 __v_24: 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_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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_25]; 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_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 __v_26: 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_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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_27]; 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_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 __v_28: 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_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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_29]; 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_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 __v_30: 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_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_31: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_31]; 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_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 __v_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+    let __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_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_33]; 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_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 __v_34: 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_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_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_35]; 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_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 __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __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_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_37]; 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_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 __v_38: G = __r_arr[0];
-    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+    let __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 __v_39: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_39]; 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_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 __v_40: G = __r_arr[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_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 __v_41: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_41]; 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_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 __v_42: 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_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_43: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_43]; 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_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 __v_44: 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_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_45: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_45]; 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_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 __v_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
     let __v_47: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __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 __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 __v_48: 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_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __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 __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 __v_50: 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_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_51]; 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_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 __v_52: G = __r_arr[0];
-    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+    let __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_53: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_53]; 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_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 __v_54: G = __r_arr[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_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_55: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_55]; 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_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 __v_56: G = __r_arr[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_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_57: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_57]; 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_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 __v_58: 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_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_59: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_59]; 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_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 __v_60: G = __r_arr[0];
-    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
+    let __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_61: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_61]; 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_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 __v_62: G = __r_arr[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_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_63: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_63]; 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_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 __v_64: 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_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_65: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_65]; 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_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 __v_66: 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_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
     let __v_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_67]; 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_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 __v_68: 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_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
     let __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_69]; 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_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 __v_70: G = __r_arr[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_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
     let __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_71]; 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_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 __v_72: 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_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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_73]; 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_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 __v_74: G = __r_arr[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_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_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_75]; 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_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 __v_76: G = __r_arr[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_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
     let __v_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_77]; 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_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 __v_78: 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_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_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_79]; 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_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 __v_80: 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_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_81: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_81]; 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_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 __v_82: 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_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_83: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_83]; 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_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 __v_84: 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_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
     let __v_85: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_85]; 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_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 __v_86: G = __r_arr[0];
     let __v_87: G = (__v_84 + __v_86);
     let __v_88: G = (__v_82 + __v_87);
@@ -31075,36 +31175,36 @@ fn aiur_fn_341(
     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_341] = [__v_128];
-    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_345] = [__v_128];
+    record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_342: usize = 5;
-const IN_342: usize = 5;
-const OUT_342: usize = 2;
-fn aiur_fn_342(
-  inp: [G; IN_342],
+const INPUT_SIZE_346: usize = 5;
+const IN_346: usize = 5;
+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_342], 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 __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __v_5: 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_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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; 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_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 __v_7: 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_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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_8]; 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_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 __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
@@ -31117,33 +31217,33 @@ fn aiur_fn_342(
             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_342] = [__v_12, __v_16];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_346] = [__v_12, __v_16];
+            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; 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_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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_13, __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_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 __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_14, __v_4]; 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_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 __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_795] = { let __args: [G; IN_795] = [__v_1, __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_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 __v_18: G = __r_arr[0];
                 let __v_19: G = G::from_u64(1);
-                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_16]; 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_309] = { let __args: [G; IN_309] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
-                let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_21, __v_18]; 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_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 __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_342] = [__v_19, __v_22];
-                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_346] = [__v_19, __v_22];
+                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -31152,8 +31252,8 @@ fn aiur_fn_342(
                 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_342] = [__v_17, __v_21];
-                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_346] = [__v_17, __v_21];
+                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -31175,33 +31275,33 @@ fn aiur_fn_342(
                 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_342] = [__v_12, __v_16];
-                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_346] = [__v_12, __v_16];
+                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; 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_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 __v_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_13, __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_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 __v_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_14, __v_4]; 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_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 __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_795] = { let __args: [G; IN_795] = [__v_1, __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_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 __v_18: G = __r_arr[0];
                     let __v_19: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_16]; 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_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 __v_20: G = __r_arr[0];
-                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
-                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_21, __v_18]; 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_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 __v_22: G = __r_arr[0];
-                    let __ret: [G; OUT_342] = [__v_19, __v_22];
-                    record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_346] = [__v_19, __v_22];
+                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -31210,8 +31310,8 @@ fn aiur_fn_342(
                     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_342] = [__v_17, __v_21];
-                    record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_346] = [__v_17, __v_21];
+                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -31222,11 +31322,11 @@ fn aiur_fn_342(
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; 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_347] = { let __args: [G; IN_347] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_342] = [__v_10, __v_11];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_346] = [__v_10, __v_11];
+            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -31241,15 +31341,15 @@ fn aiur_fn_342(
   })
 }
 
-const INPUT_SIZE_343: usize = 6;
-const IN_343: usize = 6;
-const OUT_343: usize = 2;
-fn aiur_fn_343(
-  inp: [G; IN_343],
+const INPUT_SIZE_347: usize = 6;
+const IN_347: usize = 6;
+const OUT_347: usize = 2;
+fn aiur_fn_347(
+  inp: [G; IN_347],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_343], 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];
@@ -31266,44 +31366,44 @@ fn aiur_fn_343(
         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_343] = [__v_8, __v_12];
-        record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_347] = [__v_8, __v_12];
+        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+        let __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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+        let __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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_10, __v_5]; 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_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 __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_5]; 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_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 __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_344] = { let __args: [G; IN_344] = [__v_0, __v_15, __v_17, __v_5]; 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_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 __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_795] = { let __args: [G; IN_795] = [__v_1, __v_20]; 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_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 __v_21: G = __r_arr[0];
                     let __v_22: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_19, __v_21]; 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_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 __v_23: G = __r_arr[0];
-                    let __ret: [G; OUT_343] = [__v_22, __v_23];
-                    record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_347] = [__v_22, __v_23];
+                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -31312,8 +31412,8 @@ fn aiur_fn_343(
                     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_343] = [__v_20, __v_24];
-                    record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_347] = [__v_20, __v_24];
+                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -31327,8 +31427,8 @@ fn aiur_fn_343(
                 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_343] = [__v_18, __v_22];
-                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_347] = [__v_18, __v_22];
+                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -31339,8 +31439,8 @@ fn aiur_fn_343(
             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_343] = [__v_18, __v_22];
-            record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_347] = [__v_18, __v_22];
+            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -31352,265 +31452,265 @@ fn aiur_fn_343(
   })
 }
 
-const INPUT_SIZE_344: usize = 4;
-const IN_344: usize = 4;
-const OUT_344: usize = 2;
-fn aiur_fn_344(
-  inp: [G; IN_344],
+const INPUT_SIZE_348: usize = 4;
+const IN_348: usize = 4;
+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_344], ExecError> {
+) -> Result<[G; OUT_348], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __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_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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_4]; 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_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 __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_307] = { let __args: [G; IN_307] = [__v_1, __v_2]; 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_311] = { let __args: [G; IN_311] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_344] = [__v_6, __v_9];
-        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_348] = [__v_6, __v_9];
+        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+        let __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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; 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_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 __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_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_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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_9]; 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_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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_344] = [__v_8, __v_11];
-            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_348] = [__v_8, __v_11];
+            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+            let __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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_8]; 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_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 __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_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 __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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_11]; 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_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 __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_12]; 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_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 __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_344] = [__v_10, __v_13];
-                record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_348] = [__v_10, __v_13];
+                record.function_queries[348].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_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_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_10]; 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_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 __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_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 __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 __v_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+                    let __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 __v_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14]; 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_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 __v_15: G = __r_arr[0];
-                    let __ret: [G; OUT_344] = [__v_12, __v_15];
-                    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_348] = [__v_12, __v_15];
+                    record.function_queries[348].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_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_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_12]; 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_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 __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_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 __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 __v_15: G = __r_arr[0];
-                        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_15]; 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_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 __v_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_16]; 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_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 __v_17: G = __r_arr[0];
-                        let __ret: [G; OUT_344] = [__v_14, __v_17];
-                        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_348] = [__v_14, __v_17];
+                        record.function_queries[348].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_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_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_14]; 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_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 __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_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 __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_17: G = __r_arr[0];
-                            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_17]; 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_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 __v_18: G = __r_arr[0];
-                            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_18]; 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_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 __v_19: G = __r_arr[0];
-                            let __ret: [G; OUT_344] = [__v_16, __v_19];
-                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_348] = [__v_16, __v_19];
+                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
-                            let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+                            let __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_126] = { let __args: [G; IN_126] = [__v_0, __v_16]; 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_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 __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_326] = { let __args: [G; IN_326] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
                                 let __v_19: G = __r_arr[0];
-                                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+                                let __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 __v_20: G = __r_arr[0];
-                                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
-                                let __ret: [G; OUT_344] = [__v_18, __v_21];
-                                record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_348] = [__v_18, __v_21];
+                                record.function_queries[348].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_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_18: G = __r_arr[0];
-                                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_18]; 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_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 __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_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_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 __v_21: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_21]; 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_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 __v_22: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_22]; 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_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 __v_23: G = __r_arr[0];
-                                    let __ret: [G; OUT_344] = [__v_20, __v_23];
-                                    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_348] = [__v_20, __v_23];
+                                    record.function_queries[348].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_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_20: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_20]; 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_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 __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_331] = { let __args: [G; IN_331] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+                                        let __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 __v_23: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_23]; 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_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 __v_24: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_24]; 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_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 __v_25: G = __r_arr[0];
-                                        let __ret: [G; OUT_344] = [__v_22, __v_25];
-                                        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_348] = [__v_22, __v_25];
+                                        record.function_queries[348].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_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_22: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_22]; 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_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 __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_332] = { let __args: [G; IN_332] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                                             let __v_25: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_26]; 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_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 __v_27: G = __r_arr[0];
-                                            let __ret: [G; OUT_344] = [__v_24, __v_27];
-                                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_348] = [__v_24, __v_27];
+                                            record.function_queries[348].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_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_24: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __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_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 __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_333] = { let __args: [G; IN_333] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+                                                let __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 __v_27: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_27]; 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_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 __v_28: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
-                                                let __ret: [G; OUT_344] = [__v_26, __v_29];
-                                                record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_348] = [__v_26, __v_29];
+                                                record.function_queries[348].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_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_26: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_26]; 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_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 __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_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_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 __v_29: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_29]; 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_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 __v_30: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_30]; 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_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 __v_31: G = __r_arr[0];
-                                                    let __ret: [G; OUT_344] = [__v_28, __v_31];
-                                                    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_348] = [__v_28, __v_31];
+                                                    record.function_queries[348].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_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_28: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_28]; 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_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 __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_233] = { let __args: [G; IN_233] = [__v_1, __v_2]; 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_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 __v_31: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_31, __v_3]; 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_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 __v_32: G = __r_arr[0];
-                                                        let __ret: [G; OUT_344] = [__v_30, __v_32];
-                                                        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        let __ret: [G; OUT_348] = [__v_30, __v_32];
+                                                        record.function_queries[348].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_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_30: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __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 __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 __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_312] = { let __args: [G; IN_312] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+                                                            let __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_33: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_33, __v_3]; 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_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 __v_34: G = __r_arr[0];
-                                                            let __ret: [G; OUT_344] = [__v_32, __v_34];
-                                                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_348] = [__v_32, __v_34];
+                                                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                           0u64 => {
@@ -31619,8 +31719,8 @@ fn aiur_fn_344(
                                                             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_344] = [__v_32, __v_36];
-                                                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            let __ret: [G; OUT_348] = [__v_32, __v_36];
+                                                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
@@ -31695,26 +31795,26 @@ fn aiur_fn_344(
   })
 }
 
-const INPUT_SIZE_345: usize = 2;
-const IN_345: usize = 2;
-const OUT_345: usize = 1;
-fn aiur_fn_345(
-  inp: [G; IN_345],
+const INPUT_SIZE_349: usize = 2;
+const IN_349: usize = 2;
+const OUT_349: usize = 1;
+fn aiur_fn_349(
+  inp: [G; IN_349],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_345], ExecError> {
+) -> Result<[G; OUT_349], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   0u64 => {
-    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_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 __v_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
   _ => {
-    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_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 __v_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
@@ -31722,7 +31822,7 @@ fn aiur_fn_345(
  };
     let __v_2: G = __mc_out___mc_0[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -31733,8 +31833,8 @@ fn aiur_fn_345(
         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_345] = [__v_11];
-        record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_349] = [__v_11];
+        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -31747,8 +31847,8 @@ fn aiur_fn_345(
             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_345] = [__v_12];
-            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_349] = [__v_12];
+            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -31769,8 +31869,8 @@ fn aiur_fn_345(
             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_345] = [__v_22];
-            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_349] = [__v_22];
+            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -31782,15 +31882,15 @@ fn aiur_fn_345(
   })
 }
 
-const INPUT_SIZE_346: usize = 1;
-const IN_346: usize = 1;
-const OUT_346: usize = 1;
-fn aiur_fn_346(
-  inp: [G; IN_346],
+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_346], ExecError> {
+) -> 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 };
@@ -31807,8 +31907,8 @@ fn aiur_fn_346(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_346] = [__v_11];
-        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_350] = [__v_11];
+        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -31821,8 +31921,8 @@ fn aiur_fn_346(
         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_346] = [__v_19];
-        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_350] = [__v_19];
+        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -31832,21 +31932,21 @@ fn aiur_fn_346(
   })
 }
 
-const INPUT_SIZE_347: usize = 4;
-const IN_347: usize = 4;
-const OUT_347: usize = 2;
-fn aiur_fn_347(
-  inp: [G; IN_347],
+const INPUT_SIZE_351: usize = 4;
+const IN_351: usize = 4;
+const OUT_351: usize = 2;
+fn aiur_fn_351(
+  inp: [G; IN_351],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_347], ExecError> {
+) -> Result<[G; OUT_351], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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 };
@@ -31857,20 +31957,20 @@ fn aiur_fn_347(
         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_347] = [__v_7, __v_11];
-        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_351] = [__v_7, __v_11];
+        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __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_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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_9]; 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_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 __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]; 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_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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+        let __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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -31881,14 +31981,14 @@ fn aiur_fn_347(
             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_347] = [__v_15, __v_19];
-            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_351] = [__v_15, __v_19];
+            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_14, __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_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 __v_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_15, __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 __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 __v_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             match __v_16.as_canonical_u64() {
@@ -31898,14 +31998,14 @@ 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_351] = [__v_18, __v_22];
+                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_13, __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_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 __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_18, __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 __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 __v_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
                 match __v_19.as_canonical_u64() {
@@ -31915,8 +32015,8 @@ fn aiur_fn_347(
                     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_347] = [__v_21, __v_25];
-                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_351] = [__v_21, __v_25];
+                    record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -31933,15 +32033,15 @@ fn aiur_fn_347(
                     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_326] = { let __args: [G; IN_326] = [__v_33, __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 __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 __v_34: G = __r_arr[0];
-                    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_17, __v_34]; 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_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 __v_35: G = __r_arr[0];
                     let __v_36: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_35]; 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_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 __v_37: G = __r_arr[0];
-                    let __ret: [G; OUT_347] = [__v_36, __v_37];
-                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_351] = [__v_36, __v_37];
+                    record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -31966,19 +32066,19 @@ fn aiur_fn_347(
   })
 }
 
-const INPUT_SIZE_348: usize = 2;
-const IN_348: usize = 2;
-const OUT_348: usize = 3;
-fn aiur_fn_348(
-  inp: [G; IN_348],
+const INPUT_SIZE_352: usize = 2;
+const IN_352: usize = 2;
+const OUT_352: usize = 3;
+fn aiur_fn_352(
+  inp: [G; IN_352],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_348], 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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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 __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 };
@@ -31988,15 +32088,15 @@ fn aiur_fn_348(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_8, __v_9]; 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_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 __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            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_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 __v_11: G = __r_arr[0];
             let __v_12: G = G::from_u64(2);
             let __v_13: G = (__v_11 - __v_12);
@@ -32004,13 +32104,13 @@ fn aiur_fn_348(
               0u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_15]; 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_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 __v_16: G = __r_arr[0];
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_17]; 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_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 __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_348] = [__v_14, __v_16, __v_18];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_352] = [__v_14, __v_16, __v_18];
+                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32023,8 +32123,8 @@ fn aiur_fn_348(
                 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_348] = [__v_14, __v_18, __v_22];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_352] = [__v_14, __v_18, __v_22];
+                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -32063,7 +32163,7 @@ fn aiur_fn_348(
             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_126] = { let __args: [G; IN_126] = [__v_8, __v_43]; 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_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 __v_44: G = __r_arr[0];
             match __v_44.as_canonical_u64() {
               0u64 => {
@@ -32076,12 +32176,12 @@ fn aiur_fn_348(
                 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_348] = [__v_45, __v_49, __v_53];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_352] = [__v_45, __v_49, __v_53];
+                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                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_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 __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 };
@@ -32096,15 +32196,15 @@ fn aiur_fn_348(
                     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_348] = [__v_48, __v_52, __v_56];
-                    record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_352] = [__v_48, __v_52, __v_56];
+                    record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_48]; 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_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 __v_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_49]; 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_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 __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 };
@@ -32114,11 +32214,11 @@ fn aiur_fn_348(
                     let __v_55: G = __loaded[3];
                     match __v_52.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_53]; 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_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 __v_56: G = __r_arr[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_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_57: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_56, __v_57]; 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_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 __v_58: G = __r_arr[0];
                         match __v_58.as_canonical_u64() {
                           0u64 => {
@@ -32131,12 +32231,12 @@ fn aiur_fn_348(
                             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_348] = [__v_59, __v_63, __v_67];
-                            record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_352] = [__v_59, __v_63, __v_67];
+                            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_51]; 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_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 __v_59: G = __r_arr[0];
                             let __v_60: G = G::from_u64(1);
                             let __v_61: G = (__v_59 - __v_60);
@@ -32144,13 +32244,13 @@ fn aiur_fn_348(
                               0u64 => {
                                 let __v_62: G = G::from_u64(1);
                                 let __v_63: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_51, __v_63]; 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_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 __v_64: G = __r_arr[0];
                                 let __v_65: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_65]; 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_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 __v_66: G = __r_arr[0];
-                                let __ret: [G; OUT_348] = [__v_62, __v_64, __v_66];
-                                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_352] = [__v_62, __v_64, __v_66];
+                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32163,8 +32263,8 @@ fn aiur_fn_348(
                                 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_348] = [__v_62, __v_66, __v_70];
-                                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_352] = [__v_62, __v_66, __v_70];
+                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -32184,8 +32284,8 @@ fn aiur_fn_348(
                         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_348] = [__v_56, __v_60, __v_64];
-                        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_352] = [__v_56, __v_60, __v_64];
+                        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -32215,29 +32315,29 @@ fn aiur_fn_348(
         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_348] = [__v_8, __v_12, __v_16];
-        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_352] = [__v_8, __v_12, __v_16];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_349: usize = 4;
-const IN_349: usize = 4;
-const OUT_349: usize = 2;
-fn aiur_fn_349(
-  inp: [G; IN_349],
+const INPUT_SIZE_353: usize = 4;
+const IN_353: usize = 4;
+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_349], ExecError> {
+) -> Result<[G; OUT_353], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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 };
@@ -32248,24 +32348,24 @@ fn aiur_fn_349(
         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_349] = [__v_7, __v_11];
-        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_353] = [__v_7, __v_11];
+        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __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_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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_9]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(2);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_8, __v_10, __v_1, __v_2, __v_3]; 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 __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 __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_8, __v_12, __v_1, __v_2, __v_3]; 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 __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 __v_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         match __v_13.as_canonical_u64() {
@@ -32275,8 +32375,8 @@ fn aiur_fn_349(
             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_349] = [__v_17, __v_21];
-            record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_353] = [__v_17, __v_21];
+            record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -32287,20 +32387,20 @@ fn aiur_fn_349(
                 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_349] = [__v_17, __v_21];
-                record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_353] = [__v_17, __v_21];
+                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_16, __v_14]; 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_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 __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_345] = { let __args: [G; IN_345] = [__v_19, __v_3]; 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_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 __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_349] = [__v_20, __v_21];
-                record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_353] = [__v_20, __v_21];
+                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32320,15 +32420,15 @@ fn aiur_fn_349(
   })
 }
 
-const INPUT_SIZE_350: usize = 5;
-const IN_350: usize = 5;
-const OUT_350: usize = 2;
-fn aiur_fn_350(
-  inp: [G; IN_350],
+const INPUT_SIZE_354: usize = 5;
+const IN_354: usize = 5;
+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_350], 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];
@@ -32342,7 +32442,7 @@ fn aiur_fn_350(
     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_347] = { let __args: [G; IN_347] = [__v_11, __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_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 __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     match __v_12.as_canonical_u64() {
@@ -32351,8 +32451,8 @@ fn aiur_fn_350(
         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_350] = [__v_14, __v_17];
-        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_354] = [__v_14, __v_17];
+        record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -32366,8 +32466,8 @@ fn aiur_fn_350(
             match __v_15.as_canonical_u64() {
               0u64 => {
                 let __v_18: G = G::from_u64(1);
-                let __ret: [G; OUT_350] = [__v_18, __v_16];
-                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_354] = [__v_18, __v_16];
+                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32375,8 +32475,8 @@ fn aiur_fn_350(
                 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_350] = [__v_18, __v_21];
-                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_354] = [__v_18, __v_21];
+                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -32386,8 +32486,8 @@ fn aiur_fn_350(
             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_350] = [__v_18, __v_21];
-            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_354] = [__v_18, __v_21];
+            record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -32399,60 +32499,60 @@ fn aiur_fn_350(
   })
 }
 
-const INPUT_SIZE_351: usize = 5;
-const IN_351: usize = 5;
-const OUT_351: usize = 2;
-fn aiur_fn_351(
-  inp: [G; IN_351],
+const INPUT_SIZE_355: usize = 5;
+const IN_355: usize = 5;
+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_351], ExecError> {
+) -> Result<[G; OUT_355], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    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_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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; 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_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 __v_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __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_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 __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_351] = [__v_7, __v_8];
-        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_355] = [__v_7, __v_8];
+        record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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_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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; 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_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 __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
+            let __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 __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_351] = [__v_9, __v_10];
-            record.function_queries[351].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);
           },
           0u64 => {
-            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_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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; 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_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 __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } };
+                let __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 __v_11: G = __r_arr[0];
                 let __v_12: G = __r_arr[1];
-                let __ret: [G; OUT_351] = [__v_11, __v_12];
-                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_355] = [__v_11, __v_12];
+                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -32461,8 +32561,8 @@ fn aiur_fn_351(
                 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_351] = [__v_11, __v_15];
-                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_355] = [__v_11, __v_15];
+                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32482,21 +32582,21 @@ fn aiur_fn_351(
   })
 }
 
-const INPUT_SIZE_352: usize = 4;
-const IN_352: usize = 4;
-const OUT_352: usize = 2;
-fn aiur_fn_352(
-  inp: [G; IN_352],
+const INPUT_SIZE_356: usize = 4;
+const IN_356: usize = 4;
+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_352], ExecError> {
+) -> Result<[G; OUT_356], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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 };
@@ -32507,15 +32607,15 @@ fn aiur_fn_352(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_352] = [__v_7, __v_11];
-        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_356] = [__v_7, __v_11];
+        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; 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_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 __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 };
@@ -32525,11 +32625,11 @@ fn aiur_fn_352(
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_12]; 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_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 __v_15: 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_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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_15, __v_16]; 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_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 __v_17: G = __r_arr[0];
             match __v_17.as_canonical_u64() {
               0u64 => {
@@ -32538,12 +32638,12 @@ 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_18, __v_22];
-                record.function_queries[352].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 __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_10]; 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_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 __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 };
@@ -32554,15 +32654,15 @@ fn aiur_fn_352(
                     let __v_23: G = G::from_u64(0);
                     let __v_24: G = G::from_u64(0);
                     let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_352] = [__v_21, __v_25];
-                    record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_356] = [__v_21, __v_25];
+                    record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_21: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_10, __v_21]; 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_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 __v_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; 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_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 __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 };
@@ -32572,11 +32672,11 @@ fn aiur_fn_352(
                     let __v_28: G = __loaded[3];
                     match __v_25.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 __v_29: G = __r_arr[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_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_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_29, __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 __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 __v_31: G = __r_arr[0];
                         match __v_31.as_canonical_u64() {
                           0u64 => {
@@ -32585,12 +32685,12 @@ fn aiur_fn_352(
                             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_352] = [__v_32, __v_36];
-                            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_356] = [__v_32, __v_36];
+                            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_24]; 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_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 __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 };
@@ -32601,19 +32701,19 @@ fn aiur_fn_352(
                                 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_352] = [__v_35, __v_39];
-                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_356] = [__v_35, __v_39];
+                                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_35: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_24, __v_35]; 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_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 __v_36: G = __r_arr[0];
                                 let __v_37: G = G::from_u64(2);
-                                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_10, __v_37]; 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_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 __v_38: G = __r_arr[0];
                                 let __v_39: G = G::from_u64(3);
-                                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_10, __v_39]; 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_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 __v_40: G = __r_arr[0];
                                 let __v_41: G = G::from_u64(0);
                                 let __v_42: G = G::from_u64(0);
@@ -32624,11 +32724,11 @@ fn aiur_fn_352(
                                 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_349] = { let __args: [G; IN_349] = [__v_49, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
+                                let __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 __v_50: G = __r_arr[0];
                                 let __v_51: G = __r_arr[1];
-                                let __ret: [G; OUT_352] = [__v_50, __v_51];
-                                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_356] = [__v_50, __v_51];
+                                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32647,8 +32747,8 @@ fn aiur_fn_352(
                         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_352] = [__v_29, __v_33];
-                        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_356] = [__v_29, __v_33];
+                        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -32669,8 +32769,8 @@ fn aiur_fn_352(
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(0);
             let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_352] = [__v_15, __v_19];
-            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_356] = [__v_15, __v_19];
+            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -32682,84 +32782,84 @@ fn aiur_fn_352(
   })
 }
 
-const INPUT_SIZE_353: usize = 5;
-const IN_353: usize = 5;
-const OUT_353: usize = 2;
-fn aiur_fn_353(
-  inp: [G; IN_353],
+const INPUT_SIZE_357: usize = 5;
+const IN_357: usize = 5;
+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_353], ExecError> {
+) -> Result<[G; OUT_357], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __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_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_126] = { let __args: [G; IN_126] = [__v_0, __v_5]; 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_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 __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_354] = { let __args: [G; IN_354] = []; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_353] = [__v_7, __v_8];
-        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_357] = [__v_7, __v_8];
+        record.function_queries[357].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_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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; 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_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 __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __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_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 __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_353] = [__v_9, __v_10];
-            record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_357] = [__v_9, __v_10];
+            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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_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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; 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_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 __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __v_12: G = __r_arr[1];
-                let __ret: [G; OUT_353] = [__v_11, __v_12];
-                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_357] = [__v_11, __v_12];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                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_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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; 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_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 __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_355] = { let __args: [G; IN_355] = []; 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_359] = { let __args: [G; IN_359] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
-                    let __ret: [G; OUT_353] = [__v_13, __v_14];
-                    record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_357] = [__v_13, __v_14];
+                    record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    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_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_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_13]; 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_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 __v_14: G = __r_arr[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_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_15: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                    let __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 __v_16: G = __r_arr[0];
                     let __v_17: G = (__v_14 + __v_16);
                     match __v_17.as_canonical_u64() {
@@ -32769,12 +32869,12 @@ fn aiur_fn_353(
                         let __v_20: G = G::from_u64(0);
                         let __v_21: G = G::from_u64(0);
                         let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_353] = [__v_18, __v_22];
-                        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_357] = [__v_18, __v_22];
+                        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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 };
@@ -32785,31 +32885,31 @@ fn aiur_fn_353(
                             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_353] = [__v_21, __v_25];
-                            record.function_queries[353].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);
                           },
                           0u64 => {
                             let __v_21: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_21]; 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_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 __v_22: G = __r_arr[0];
-                            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_22, __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_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 __v_23: G = __r_arr[0];
                             match __v_14.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_23, __v_4]; 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_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 __v_24: G = __r_arr[0];
                                 let __v_25: G = __r_arr[1];
-                                let __ret: [G; OUT_353] = [__v_24, __v_25];
-                                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_357] = [__v_24, __v_25];
+                                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_23]; 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_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 __v_24: G = __r_arr[0];
                                 let __v_25: G = __r_arr[1];
-                                let __ret: [G; OUT_353] = [__v_24, __v_25];
-                                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_357] = [__v_24, __v_25];
+                                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -32846,15 +32946,15 @@ fn aiur_fn_353(
   })
 }
 
-const INPUT_SIZE_354: usize = 0;
-const IN_354: usize = 0;
-const OUT_354: usize = 1;
-fn aiur_fn_354(
-  inp: [G; IN_354],
+const INPUT_SIZE_358: usize = 0;
+const IN_358: usize = 0;
+const OUT_358: usize = 1;
+fn aiur_fn_358(
+  inp: [G; IN_358],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_354], ExecError> {
+) -> Result<[G; OUT_358], 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);
@@ -32873,21 +32973,21 @@ fn aiur_fn_354(
     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_354] = [__v_16];
-    record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_358] = [__v_16];
+    record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_355: usize = 0;
-const IN_355: usize = 0;
-const OUT_355: usize = 1;
-fn aiur_fn_355(
-  inp: [G; IN_355],
+const INPUT_SIZE_359: usize = 0;
+const IN_359: usize = 0;
+const OUT_359: usize = 1;
+fn aiur_fn_359(
+  inp: [G; IN_359],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_355], ExecError> {
+) -> Result<[G; OUT_359], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(1);
@@ -32906,25 +33006,25 @@ fn aiur_fn_355(
     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_355] = [__v_16];
-    record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_359] = [__v_16];
+    record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_356: usize = 2;
-const IN_356: usize = 2;
-const OUT_356: usize = 2;
-fn aiur_fn_356(
-  inp: [G; IN_356],
+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_356], ExecError> {
+) -> Result<[G; OUT_360], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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 };
@@ -32935,15 +33035,15 @@ fn aiur_fn_356(
         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_356] = [__v_5, __v_9];
-        record.function_queries[356].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);
       },
       0u64 => {
         let __v_5: G = G::from_u64(2);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_5]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; 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_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 __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 };
@@ -32953,19 +33053,19 @@ fn aiur_fn_356(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __v_13: G = __r_arr[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_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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_14]; 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_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 __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_354] = { let __args: [G; IN_354] = []; 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_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 __v_17: G = __r_arr[0];
-                let __ret: [G; OUT_356] = [__v_16, __v_17];
-                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_360] = [__v_16, __v_17];
+                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -32974,8 +33074,8 @@ fn aiur_fn_356(
                 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_356] = [__v_16, __v_20];
-                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_360] = [__v_16, __v_20];
+                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -32989,8 +33089,8 @@ fn aiur_fn_356(
             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_356] = [__v_13, __v_17];
-            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_360] = [__v_13, __v_17];
+            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33002,19 +33102,19 @@ fn aiur_fn_356(
   })
 }
 
-const INPUT_SIZE_357: usize = 2;
-const IN_357: usize = 2;
-const OUT_357: usize = 2;
-fn aiur_fn_357(
-  inp: [G; IN_357],
+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_357], 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_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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 };
@@ -33025,15 +33125,15 @@ fn aiur_fn_357(
         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_357] = [__v_5, __v_9];
-        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_361] = [__v_5, __v_9];
+        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_5]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; 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_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 __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 };
@@ -33043,15 +33143,15 @@ fn aiur_fn_357(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __v_13: 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_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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_14]; 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_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 __v_15: 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_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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_16]; 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_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 __v_17: G = __r_arr[0];
             let __v_18: G = (__v_15 + __v_17);
             match __v_18.as_canonical_u64() {
@@ -33061,16 +33161,16 @@ fn aiur_fn_357(
                 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_357] = [__v_19, __v_23];
-                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_361] = [__v_19, __v_23];
+                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_19: G = G::from_u64(1);
-                let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = []; 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_359] = { let __args: [G; IN_359] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
-                let __ret: [G; OUT_357] = [__v_19, __v_20];
-                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_361] = [__v_19, __v_20];
+                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -33081,8 +33181,8 @@ fn aiur_fn_357(
             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_357] = [__v_13, __v_17];
-            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_361] = [__v_13, __v_17];
+            record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33094,15 +33194,15 @@ fn aiur_fn_357(
   })
 }
 
-const INPUT_SIZE_358: usize = 2;
-const IN_358: usize = 2;
-const OUT_358: usize = 2;
-fn aiur_fn_358(
-  inp: [G; IN_358],
+const INPUT_SIZE_362: usize = 2;
+const IN_362: usize = 2;
+const OUT_362: usize = 2;
+fn aiur_fn_362(
+  inp: [G; IN_362],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_358], ExecError> {
+) -> Result<[G; OUT_362], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33113,15 +33213,15 @@ fn aiur_fn_358(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; 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_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 __v_8: G = __r_arr[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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_9]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = (__v_8 + __v_10);
         match __v_11.as_canonical_u64() {
@@ -33131,14 +33231,14 @@ 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_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_358] = [__v_12, __v_16];
-            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_362] = [__v_12, __v_16];
+            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(1);
-            let __ret: [G; OUT_358] = [__v_12, __v_0];
-            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_362] = [__v_12, __v_0];
+            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33149,23 +33249,23 @@ fn aiur_fn_358(
         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_358] = [__v_6, __v_10];
-        record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_362] = [__v_6, __v_10];
+        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_359: usize = 1;
-const IN_359: usize = 1;
-const OUT_359: usize = 2;
-fn aiur_fn_359(
-  inp: [G; IN_359],
+const INPUT_SIZE_363: usize = 1;
+const IN_363: usize = 1;
+const OUT_363: usize = 2;
+fn aiur_fn_363(
+  inp: [G; IN_363],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_359], ExecError> {
+) -> Result<[G; OUT_363], 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 };
@@ -33178,8 +33278,8 @@ fn aiur_fn_359(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_359] = [__v_5, __v_0];
-            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_363] = [__v_5, __v_0];
+            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -33188,8 +33288,8 @@ fn aiur_fn_359(
             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_359] = [__v_5, __v_9];
-            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_363] = [__v_5, __v_9];
+            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33200,23 +33300,23 @@ fn aiur_fn_359(
         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_359] = [__v_5, __v_9];
-        record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_363] = [__v_5, __v_9];
+        record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_360: usize = 7;
-const IN_360: usize = 7;
-const OUT_360: usize = 2;
-fn aiur_fn_360(
-  inp: [G; IN_360],
+const INPUT_SIZE_364: usize = 7;
+const IN_364: usize = 7;
+const OUT_364: usize = 2;
+fn aiur_fn_364(
+  inp: [G; IN_364],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_360], ExecError> {
+) -> Result<[G; OUT_364], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33225,39 +33325,39 @@ fn aiur_fn_360(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    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_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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_7]; 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_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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+    let __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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_9]; 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_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 __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_11]; 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_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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
+    let __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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_13]; 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_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 __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
+    let __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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __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 __v_16: 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_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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_17]; 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_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 __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_363] = { let __args: [G; IN_363] = [__v_1, __v_2, __v_3, __v_4, __v_5, __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 __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 __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
-        let __ret: [G; OUT_360] = [__v_21, __v_22];
-        record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_364] = [__v_21, __v_22];
+        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33270,12 +33370,12 @@ fn aiur_fn_360(
             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_360] = [__v_23, __v_27];
-            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_364] = [__v_23, __v_27];
+            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            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_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 __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 };
@@ -33286,16 +33386,16 @@ fn aiur_fn_360(
                 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_360] = [__v_26, __v_30];
-                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_364] = [__v_26, __v_30];
+                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__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[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_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 __v_26: G = __r_arr[0];
                 let __v_27: G = __r_arr[1];
-                let __ret: [G; OUT_360] = [__v_26, __v_27];
-                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_364] = [__v_26, __v_27];
+                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33309,15 +33409,15 @@ fn aiur_fn_360(
   })
 }
 
-const INPUT_SIZE_361: usize = 2;
-const IN_361: usize = 2;
-const OUT_361: usize = 3;
-fn aiur_fn_361(
-  inp: [G; IN_361],
+const INPUT_SIZE_365: usize = 2;
+const IN_365: usize = 2;
+const OUT_365: usize = 3;
+fn aiur_fn_365(
+  inp: [G; IN_365],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_361], 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];
@@ -33335,15 +33435,15 @@ fn aiur_fn_361(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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_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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_11]; 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_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 __v_12: 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_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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_13]; 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_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 __v_14: G = __r_arr[0];
             let __v_15: G = (__v_12 + __v_14);
             match __v_15.as_canonical_u64() {
@@ -33353,8 +33453,8 @@ fn aiur_fn_361(
                 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_361] = [__v_16, __v_17, __v_20];
-                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_365] = [__v_16, __v_17, __v_20];
+                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33368,8 +33468,8 @@ fn aiur_fn_361(
                     match __v_17.as_canonical_u64() {
                       0u64 => {
                         let __v_20: G = G::from_u64(1);
-                        let __ret: [G; OUT_361] = [__v_20, __v_14, __v_18];
-                        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_365] = [__v_20, __v_14, __v_18];
+                        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -33378,8 +33478,8 @@ fn aiur_fn_361(
                         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_361] = [__v_20, __v_21, __v_24];
-                        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_365] = [__v_20, __v_21, __v_24];
+                        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -33390,8 +33490,8 @@ fn aiur_fn_361(
                     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_361] = [__v_20, __v_21, __v_24];
-                    record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_365] = [__v_20, __v_21, __v_24];
+                    record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -33404,8 +33504,8 @@ fn aiur_fn_361(
             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_361] = [__v_10, __v_11, __v_14];
-            record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_365] = [__v_10, __v_11, __v_14];
+            record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33416,35 +33516,35 @@ fn aiur_fn_361(
         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_361] = [__v_6, __v_7, __v_10];
-        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_365] = [__v_6, __v_7, __v_10];
+        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_362: usize = 3;
-const IN_362: usize = 3;
-const OUT_362: usize = 2;
-fn aiur_fn_362(
-  inp: [G; IN_362],
+const INPUT_SIZE_366: usize = 3;
+const IN_366: usize = 3;
+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_362], ExecError> {
+) -> Result<[G; OUT_366], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   0u64 => {
-    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_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_3: G = __r_arr[0];
     break '__mc_0 [__v_3];
   },
   _ => {
-    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_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_3: G = __r_arr[0];
     break '__mc_0 [__v_3];
   },
@@ -33452,7 +33552,7 @@ fn aiur_fn_362(
  };
     let __v_3: G = __mc_out___mc_0[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __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 __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
@@ -33465,12 +33565,12 @@ fn aiur_fn_362(
         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_340] = { let __args: [G; IN_340] = [__v_1]; 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_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 __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_362] = [__v_13, __v_17];
-        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_366] = [__v_13, __v_17];
+        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -33479,8 +33579,8 @@ fn aiur_fn_362(
         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_362] = [__v_7, __v_11];
-        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_366] = [__v_7, __v_11];
+        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33490,15 +33590,15 @@ fn aiur_fn_362(
   })
 }
 
-const INPUT_SIZE_363: usize = 6;
-const IN_363: usize = 6;
-const OUT_363: usize = 2;
-fn aiur_fn_363(
-  inp: [G; IN_363],
+const INPUT_SIZE_367: usize = 6;
+const IN_367: usize = 6;
+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_363], 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];
@@ -33506,7 +33606,7 @@ fn aiur_fn_363(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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 };
@@ -33517,24 +33617,24 @@ fn aiur_fn_363(
         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_363] = [__v_9, __v_13];
-        record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_367] = [__v_9, __v_13];
+        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_9]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_10, __v_5]; 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_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 __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_361] = { let __args: [G; IN_361] = [__v_12, __v_5]; 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_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 __v_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             let __v_18: G = __r_arr[2];
@@ -33545,26 +33645,26 @@ fn aiur_fn_363(
                 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_363] = [__v_19, __v_23];
-                record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_367] = [__v_19, __v_23];
+                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__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[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_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 __v_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
-                let __ret: [G; OUT_363] = [__v_19, __v_20];
-                record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_367] = [__v_19, __v_20];
+                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__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[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_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 __v_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __ret: [G; OUT_363] = [__v_16, __v_17];
-            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_367] = [__v_16, __v_17];
+            record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33576,15 +33676,15 @@ fn aiur_fn_363(
   })
 }
 
-const INPUT_SIZE_364: usize = 8;
-const IN_364: usize = 8;
-const OUT_364: usize = 2;
-fn aiur_fn_364(
-  inp: [G; IN_364],
+const INPUT_SIZE_368: usize = 8;
+const IN_368: usize = 8;
+const OUT_368: usize = 2;
+fn aiur_fn_368(
+  inp: [G; IN_368],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_364], 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];
@@ -33594,28 +33694,28 @@ fn aiur_fn_364(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_3, __v_5, __v_6, __v_7]; 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_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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __v_7]; 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_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 __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_8, __v_7]; 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_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 __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_361] = { let __args: [G; IN_361] = [__v_9, __v_7]; 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_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 __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_362] = { let __args: [G; IN_362] = [__v_11, __v_12, __v_7]; 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_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 __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_362] = { let __args: [G; IN_362] = [__v_14, __v_15, __v_7]; 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_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 __v_18: G = __r_arr[0];
                 let __v_19: G = __r_arr[1];
                 match __v_18.as_canonical_u64() {
@@ -33630,13 +33730,13 @@ fn aiur_fn_364(
                     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_795] = { let __args: [G; IN_795] = [__v_2, __v_29]; 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_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 __v_30: G = __r_arr[0];
                     let __v_31: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_28, __v_30]; 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_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 __v_32: G = __r_arr[0];
-                    let __ret: [G; OUT_364] = [__v_31, __v_32];
-                    record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_368] = [__v_31, __v_32];
+                    record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -33645,8 +33745,8 @@ fn aiur_fn_364(
                     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_364] = [__v_20, __v_24];
-                    record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_368] = [__v_20, __v_24];
+                    record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -33657,8 +33757,8 @@ fn aiur_fn_364(
                 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_364] = [__v_18, __v_22];
-                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_368] = [__v_18, __v_22];
+                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -33669,8 +33769,8 @@ fn aiur_fn_364(
             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_364] = [__v_16, __v_20];
-            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_368] = [__v_16, __v_20];
+            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -33681,23 +33781,23 @@ fn aiur_fn_364(
         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_364] = [__v_13, __v_17];
-        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_368] = [__v_13, __v_17];
+        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_365: usize = 9;
-const IN_365: usize = 9;
-const OUT_365: usize = 2;
-fn aiur_fn_365(
-  inp: [G; IN_365],
+const INPUT_SIZE_369: usize = 9;
+const IN_369: usize = 9;
+const OUT_369: usize = 2;
+fn aiur_fn_369(
+  inp: [G; IN_369],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_365], 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];
@@ -33711,14 +33811,14 @@ fn aiur_fn_365(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_9]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_10, __v_6, __v_7, __v_8]; 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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+        let __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 __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
@@ -33728,14 +33828,14 @@ fn aiur_fn_365(
             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_365] = [__v_16, __v_20];
-            record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_369] = [__v_16, __v_20];
+            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_15]; 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_309] = { let __args: [G; IN_309] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_16]; 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_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 __v_17: G = __r_arr[0];
             let __v_18: G = G::from_u64(2);
             let __v_19: G = G::from_u64(0);
@@ -33744,10 +33844,10 @@ fn aiur_fn_365(
             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_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_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_25: G = __r_arr[0];
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_25, __v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __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 __v_27: G = __r_arr[0];
             let __v_28: G = __r_arr[1];
             match __v_27.as_canonical_u64() {
@@ -33757,8 +33857,8 @@ fn aiur_fn_365(
                 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_365] = [__v_29, __v_33];
-                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_369] = [__v_29, __v_33];
+                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -33775,13 +33875,13 @@ fn aiur_fn_365(
                 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_795] = { let __args: [G; IN_795] = [__v_5, __v_41]; 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_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 __v_42: G = __r_arr[0];
-                let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_40, __v_42]; 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_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 __v_43: G = __r_arr[0];
                 let __v_44: G = G::from_u64(1);
-                let __ret: [G; OUT_365] = [__v_44, __v_43];
-                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_369] = [__v_44, __v_43];
+                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -33795,11 +33895,11 @@ fn aiur_fn_365(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__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[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_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 __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __ret: [G; OUT_365] = [__v_9, __v_10];
-        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_369] = [__v_9, __v_10];
+        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -33809,15 +33909,15 @@ fn aiur_fn_365(
   })
 }
 
-const INPUT_SIZE_366: usize = 8;
-const IN_366: usize = 8;
-const OUT_366: usize = 2;
-fn aiur_fn_366(
-  inp: [G; IN_366],
+const INPUT_SIZE_370: usize = 8;
+const IN_370: usize = 8;
+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_366], 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];
@@ -33828,19 +33928,19 @@ fn aiur_fn_366(
     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_777] = { let __args: [G; IN_777] = [__v_4, __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_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 __v_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(1);
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __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_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 __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_9, __v_5, __v_6, __v_7]; 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_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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_11, __v_5, __v_6, __v_7]; 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_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 __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_12, __v_7]; 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_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 __v_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_7]; 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_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 __v_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
     match __v_14.as_canonical_u64() {
@@ -33850,8 +33950,8 @@ fn aiur_fn_366(
         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_366] = [__v_18, __v_22];
-        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_370] = [__v_18, __v_22];
+        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -33862,19 +33962,19 @@ fn aiur_fn_366(
             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_366] = [__v_18, __v_22];
-            record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_370] = [__v_18, __v_22];
+            record.function_queries[370].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_312] = { let __args: [G; IN_312] = [__v_15, __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 __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 __v_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
   0u64 => {
-    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_15, __v_17]; 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_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 __v_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
@@ -33884,11 +33984,11 @@ fn aiur_fn_366(
 }
  };
             let __v_18: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__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[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_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 __v_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_366] = [__v_19, __v_20];
-            record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_370] = [__v_19, __v_20];
+            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -33903,15 +34003,15 @@ fn aiur_fn_366(
   })
 }
 
-const INPUT_SIZE_367: usize = 11;
-const IN_367: usize = 11;
-const OUT_367: usize = 2;
-fn aiur_fn_367(
-  inp: [G; IN_367],
+const INPUT_SIZE_371: usize = 11;
+const IN_371: usize = 11;
+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_367], 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];
@@ -33924,10 +34024,10 @@ fn aiur_fn_367(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    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_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __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 __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     match __v_13.as_canonical_u64() {
@@ -33937,15 +34037,15 @@ fn aiur_fn_367(
         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_367] = [__v_15, __v_19];
-        record.function_queries[367].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_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_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_15: G = __r_arr[0];
         let __v_16: G = G::from_u64(0);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_15, __v_10, __v_16]; 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_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 __v_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         match __v_17.as_canonical_u64() {
@@ -33955,26 +34055,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_371] = [__v_19, __v_23];
+            record.function_queries[371].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_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_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 __v_19: G = __r_arr[0];
     let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_19, __v_10, __v_20]; 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_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 __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_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_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 __v_19: G = __r_arr[0];
     let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_19, __v_10, __v_20]; 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_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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -33993,8 +34093,8 @@ fn aiur_fn_367(
                 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_367] = [__v_21, __v_25];
-                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_371] = [__v_21, __v_25];
+                record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -34034,12 +34134,12 @@ fn aiur_fn_367(
   1u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        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_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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
       0u64 => {
-        let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
+        let __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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
@@ -34051,12 +34151,12 @@ fn aiur_fn_367(
   0u64 => {
     match __v_2.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_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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
       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_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_53: G = __r_arr[0];
         break '__mc_1 [__v_53];
       },
@@ -34072,7 +34172,7 @@ fn aiur_fn_367(
  };
                 let __v_53: G = __mc_out___mc_1[0];
                 let __v_54: G = G::from_u64(0);
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_53, __v_10, __v_54]; 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_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 __v_55: G = __r_arr[0];
                 let __v_56: G = __r_arr[1];
                 match __v_55.as_canonical_u64() {
@@ -34082,8 +34182,8 @@ fn aiur_fn_367(
                     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_367] = [__v_57, __v_61];
-                    record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_371] = [__v_57, __v_61];
+                    record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -34097,8 +34197,8 @@ fn aiur_fn_367(
                         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_367] = [__v_60, __v_64];
-                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_371] = [__v_60, __v_64];
+                        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
@@ -34117,11 +34217,11 @@ fn aiur_fn_367(
                         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_368] = { let __args: [G; IN_368] = [__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[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_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 __v_75: G = __r_arr[0];
                         let __v_76: G = __r_arr[1];
-                        let __ret: [G; OUT_367] = [__v_75, __v_76];
-                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_371] = [__v_75, __v_76];
+                        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -34151,15 +34251,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_372: usize = 8;
+const IN_372: usize = 8;
+const OUT_372: usize = 2;
+fn aiur_fn_372(
+  inp: [G; IN_372],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_368], 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];
@@ -34171,12 +34271,12 @@ fn aiur_fn_368(
     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_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_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_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
   0u64 => {
-    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_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_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -34187,7 +34287,7 @@ fn aiur_fn_368(
  };
     let __v_8: G = __mc_out___mc_0[0];
     let __v_9: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     match __v_10.as_canonical_u64() {
@@ -34197,8 +34297,8 @@ fn aiur_fn_368(
         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_368] = [__v_12, __v_16];
-        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_372] = [__v_12, __v_16];
+        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -34206,18 +34306,18 @@ fn aiur_fn_368(
         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_791] = { let __args: [G; IN_791] = [__v_4, __v_15]; 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_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 __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_14, __v_16]; 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_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 __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_17, __v_5, __v_6, __v_7]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_18, __v_5, __v_6, __v_7]; 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_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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_19]; 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_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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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 };
@@ -34228,13 +34328,13 @@ fn aiur_fn_368(
             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_368] = [__v_25, __v_29];
-            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_372] = [__v_25, __v_29];
+            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_25: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_21, __v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = G::from_u64(2);
             let __v_28: G = G::from_u64(1);
@@ -34249,13 +34349,13 @@ fn aiur_fn_368(
             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_795] = { let __args: [G; IN_795] = [__v_4, __v_39]; 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_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 __v_40: G = __r_arr[0];
             let __v_41: G = G::from_u64(1);
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_38, __v_40]; 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_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 __v_42: G = __r_arr[0];
-            let __ret: [G; OUT_368] = [__v_41, __v_42];
-            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_372] = [__v_41, __v_42];
+            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34270,20 +34370,20 @@ fn aiur_fn_368(
   })
 }
 
-const INPUT_SIZE_369: usize = 3;
-const IN_369: usize = 3;
-const OUT_369: usize = 2;
-fn aiur_fn_369(
-  inp: [G; IN_369],
+const INPUT_SIZE_373: usize = 3;
+const IN_373: usize = 3;
+const OUT_373: usize = 2;
+fn aiur_fn_373(
+  inp: [G; IN_373],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_369], ExecError> {
+) -> Result<[G; OUT_373], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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 };
@@ -34294,13 +34394,13 @@ fn aiur_fn_369(
         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_369] = [__v_6, __v_10];
-        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_373] = [__v_6, __v_10];
+        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_6]; 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_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 __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];
@@ -34311,13 +34411,13 @@ fn aiur_fn_369(
           7u64 => {
             match __v_9.as_canonical_u64() {
               1u64 => {
-                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_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_12]; 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_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 __v_13: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 __v_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
                     let __v_16: G = __r_arr[2];
@@ -34336,32 +34436,32 @@ fn aiur_fn_369(
                     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_369] = [__v_27, __v_31];
-                    record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_373] = [__v_27, __v_31];
+                    record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    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_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_14]; 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_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 __v_15: G = __r_arr[0];
                     match __v_15.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_10, __v_2]; 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_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 __v_16: G = __r_arr[0];
                         let __v_17: G = __r_arr[1];
-                        let __ret: [G; OUT_369] = [__v_16, __v_17];
-                        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_373] = [__v_16, __v_17];
+                        record.function_queries[373].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_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
                         let __v_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_16]; 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_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 __v_17: 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_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
                         let __v_18: G = __r_arr[0];
-                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_18]; 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_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 __v_19: G = __r_arr[0];
                         let __v_20: G = (__v_17 + __v_19);
                         match __v_20.as_canonical_u64() {
@@ -34371,16 +34471,16 @@ fn aiur_fn_369(
                             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_369] = [__v_21, __v_25];
-                            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_373] = [__v_21, __v_25];
+                            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_10, __v_2]; 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_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 __v_21: G = __r_arr[0];
                             let __v_22: G = __r_arr[1];
-                            let __ret: [G; OUT_369] = [__v_21, __v_22];
-                            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_373] = [__v_21, __v_22];
+                            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -34401,8 +34501,8 @@ fn aiur_fn_369(
                 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_369] = [__v_12, __v_16];
-                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_373] = [__v_12, __v_16];
+                record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -34413,8 +34513,8 @@ fn aiur_fn_369(
             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_369] = [__v_12, __v_16];
-            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_373] = [__v_12, __v_16];
+            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -34426,15 +34526,15 @@ fn aiur_fn_369(
   })
 }
 
-const INPUT_SIZE_370: usize = 2;
-const IN_370: usize = 2;
-const OUT_370: usize = 2;
-fn aiur_fn_370(
-  inp: [G; IN_370],
+const INPUT_SIZE_374: usize = 2;
+const IN_374: usize = 2;
+const OUT_374: usize = 2;
+fn aiur_fn_374(
+  inp: [G; IN_374],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_370], 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];
@@ -34444,10 +34544,10 @@ fn aiur_fn_370(
     let __v_4: G = __loaded[2];
     match __v_2.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_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_6]; 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_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 __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         match __v_7.as_canonical_u64() {
@@ -34459,8 +34559,8 @@ fn aiur_fn_370(
             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_370] = [__v_9, __v_15];
-            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_374] = [__v_9, __v_15];
+            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -34469,8 +34569,8 @@ fn aiur_fn_370(
             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_370] = [__v_9, __v_13];
-            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_374] = [__v_9, __v_13];
+            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -34484,30 +34584,30 @@ fn aiur_fn_370(
         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_370] = [__v_5, __v_9];
-        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_374] = [__v_5, __v_9];
+        record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_371: usize = 2;
-const IN_371: usize = 2;
-const OUT_371: usize = 2;
-fn aiur_fn_371(
-  inp: [G; IN_371],
+const INPUT_SIZE_375: usize = 2;
+const IN_375: usize = 2;
+const OUT_375: usize = 2;
+fn aiur_fn_375(
+  inp: [G; IN_375],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_371], 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 __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_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -34517,14 +34617,14 @@ fn aiur_fn_371(
         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_371] = [__v_6, __v_10];
-        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_375] = [__v_6, __v_10];
+        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__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_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 __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(7);
         let __v_9: G = G::from_u64(0);
@@ -34540,8 +34640,8 @@ fn aiur_fn_371(
         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_371] = [__v_18, __v_21];
-        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_375] = [__v_18, __v_21];
+        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -34551,51 +34651,51 @@ fn aiur_fn_371(
   })
 }
 
-const INPUT_SIZE_372: usize = 1;
-const IN_372: usize = 1;
-const OUT_372: usize = 4;
-fn aiur_fn_372(
-  inp: [G; IN_372],
+const INPUT_SIZE_376: usize = 1;
+const IN_376: usize = 1;
+const OUT_376: usize = 4;
+fn aiur_fn_376(
+  inp: [G; IN_376],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_372], ExecError> {
+) -> Result<[G; OUT_376], 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_314] = { let __args: [G; IN_314] = [__v_0, __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_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 __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_314] = { let __args: [G; IN_314] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __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 __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_314] = { let __args: [G; IN_314] = [__v_6, __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_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 __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_314] = { let __args: [G; IN_314] = [__v_9, __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_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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __ret: [G; OUT_372] = [__v_2, __v_5, __v_8, __v_11];
-    record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_376] = [__v_2, __v_5, __v_8, __v_11];
+    record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_373: usize = 1;
-const IN_373: usize = 1;
-const OUT_373: usize = 1;
-fn aiur_fn_373(
-  inp: [G; IN_373],
+const INPUT_SIZE_377: usize = 1;
+const IN_377: usize = 1;
+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_373], ExecError> {
+) -> Result<[G; OUT_377], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { 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_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -34629,41 +34729,41 @@ fn aiur_fn_373(
     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_373] = [__v_30];
-    record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_377] = [__v_30];
+    record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_374: usize = 1;
-const IN_374: usize = 1;
-const OUT_374: usize = 1;
-fn aiur_fn_374(
-  inp: [G; IN_374],
+const INPUT_SIZE_378: usize = 1;
+const IN_378: usize = 1;
+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_374], ExecError> {
+) -> Result<[G; OUT_378], 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_375] = { let __args: [G; IN_375] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+    let __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 __v_2: G = __r_arr[0];
-    let __ret: [G; OUT_374] = [__v_2];
-    record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_378] = [__v_2];
+    record.function_queries[378].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 = 1;
-fn aiur_fn_375(
-  inp: [G; IN_375],
+const INPUT_SIZE_379: usize = 2;
+const IN_379: usize = 2;
+const OUT_379: usize = 1;
+fn aiur_fn_379(
+  inp: [G; IN_379],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_375], 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];
@@ -34673,18 +34773,18 @@ fn aiur_fn_375(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_375] = [__v_1];
-        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_1];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_375] = [__v_7];
-        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_7];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -34694,15 +34794,15 @@ fn aiur_fn_375(
   })
 }
 
-const INPUT_SIZE_376: usize = 2;
-const IN_376: usize = 2;
-const OUT_376: usize = 2;
-fn aiur_fn_376(
-  inp: [G; IN_376],
+const INPUT_SIZE_380: usize = 2;
+const IN_380: usize = 2;
+const OUT_380: usize = 2;
+fn aiur_fn_380(
+  inp: [G; IN_380],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_376], 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];
@@ -34710,8 +34810,8 @@ fn aiur_fn_376(
     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_376] = [__v_0, __v_1];
-        record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_380] = [__v_0, __v_1];
+        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -34732,8 +34832,8 @@ fn aiur_fn_376(
                 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_376] = [__v_15, __v_8];
-                record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_380] = [__v_15, __v_8];
+                record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -34770,8 +34870,8 @@ fn aiur_fn_376(
                         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_376] = [__v_25, __v_13];
-                        record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_380] = [__v_25, __v_13];
+                        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -34820,8 +34920,8 @@ fn aiur_fn_376(
                             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_376] = [__v_33, __v_16];
-                            record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_380] = [__v_33, __v_16];
+                            record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -34856,22 +34956,22 @@ fn aiur_fn_376(
   })
 }
 
-const INPUT_SIZE_377: usize = 2;
-const IN_377: usize = 2;
-const OUT_377: usize = 2;
-fn aiur_fn_377(
-  inp: [G; IN_377],
+const INPUT_SIZE_381: usize = 2;
+const IN_381: usize = 2;
+const OUT_381: usize = 2;
+fn aiur_fn_381(
+  inp: [G; IN_381],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_377], 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_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_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 __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -34881,15 +34981,15 @@ fn aiur_fn_377(
         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_377] = [__v_6, __v_10];
-        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_381] = [__v_6, __v_10];
+        record.function_queries[381].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_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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_1, __v_7]; 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_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 __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -34899,15 +34999,15 @@ fn aiur_fn_377(
             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_377] = [__v_10, __v_14];
-            record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_381] = [__v_10, __v_14];
+            record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_10, __v_1, __v_11]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
@@ -34917,15 +35017,15 @@ fn aiur_fn_377(
                 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_377] = [__v_14, __v_18];
-                record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_381] = [__v_14, __v_18];
+                record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                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_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_14, __v_1, __v_15]; 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_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 __v_16: G = __r_arr[0];
                 let __v_17: G = __r_arr[1];
                 match __v_16.as_canonical_u64() {
@@ -34935,15 +35035,15 @@ fn aiur_fn_377(
                     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_377] = [__v_18, __v_22];
-                    record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_381] = [__v_18, __v_22];
+                    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    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_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 __v_18: G = __r_arr[0];
                     let __v_19: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_18, __v_1, __v_19]; 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_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 __v_20: G = __r_arr[0];
                     let __v_21: G = __r_arr[1];
                     match __v_20.as_canonical_u64() {
@@ -34953,8 +35053,8 @@ fn aiur_fn_377(
                         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_377] = [__v_22, __v_26];
-                        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_381] = [__v_22, __v_26];
+                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
@@ -34996,14 +35096,14 @@ fn aiur_fn_377(
                         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_378] = { let __args: [G; IN_378] = [__v_0, __v_56, __v_59, __v_47]; 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_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 __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_377] = [__v_61, __v_64];
-                        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_381] = [__v_61, __v_64];
+                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -35033,15 +35133,15 @@ fn aiur_fn_377(
   })
 }
 
-const INPUT_SIZE_378: usize = 4;
-const IN_378: usize = 4;
-const OUT_378: usize = 1;
-fn aiur_fn_378(
-  inp: [G; IN_378],
+const INPUT_SIZE_382: usize = 4;
+const IN_382: usize = 4;
+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_378], 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];
@@ -35053,15 +35153,15 @@ fn aiur_fn_378(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_378] = [__v_1];
-        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_382] = [__v_1];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_5, __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 __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 __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } };
+        let __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 __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(7);
         let __v_11: G = G::from_u64(0);
@@ -35073,13 +35173,13 @@ fn aiur_fn_378(
         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_378] = { let __args: [G; IN_378] = [__v_8, __v_1, __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 __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 __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_378] = [__v_23];
-        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_382] = [__v_23];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35089,15 +35189,15 @@ fn aiur_fn_378(
   })
 }
 
-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_383: usize = 2;
+const IN_383: usize = 2;
+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_379], ExecError> {
+) -> Result<[G; OUT_383], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -35110,18 +35210,18 @@ fn aiur_fn_379(
       7u64 => {
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __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 __v_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_379] = [__v_7];
-                record.function_queries[379].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);
               },
               0u64 => {
-                let __ret: [G; OUT_379] = [__v_0];
-                record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_383] = [__v_0];
+                record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -35130,35 +35230,35 @@ fn aiur_fn_379(
             }
           },
           _ => {
-            let __ret: [G; OUT_379] = [__v_0];
-            record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_383] = [__v_0];
+            record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_379] = [__v_0];
-        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_383] = [__v_0];
+        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_380: usize = 3;
-const IN_380: usize = 3;
-const OUT_380: usize = 2;
-fn aiur_fn_380(
-  inp: [G; IN_380],
+const INPUT_SIZE_384: usize = 3;
+const IN_384: usize = 3;
+const OUT_384: usize = 2;
+fn aiur_fn_384(
+  inp: [G; IN_384],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_380], ExecError> {
+) -> Result<[G; OUT_384], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __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_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_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];
@@ -35175,7 +35275,7 @@ fn aiur_fn_380(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } };
+        let __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 __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
         let __v_18: G = __r_arr[2];
@@ -35183,7 +35283,7 @@ fn aiur_fn_380(
         let __v_20: G = __r_arr[4];
         match __v_16.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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() {
@@ -35193,22 +35293,22 @@ fn aiur_fn_380(
                 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_380] = [__v_23, __v_27];
-                record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_384] = [__v_23, __v_27];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_20]; 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_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 __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_795] = { let __args: [G; IN_795] = [__v_1, __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_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 __v_26: G = __r_arr[0];
                 let __v_27: G = G::from_u64(1);
-                let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_25, __v_26]; 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_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 __v_28: G = __r_arr[0];
-                let __ret: [G; OUT_380] = [__v_27, __v_28];
-                record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_384] = [__v_27, __v_28];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -35222,8 +35322,8 @@ fn aiur_fn_380(
             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_380] = [__v_21, __v_25];
-            record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_384] = [__v_21, __v_25];
+            record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35234,34 +35334,34 @@ fn aiur_fn_380(
         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_380] = [__v_15, __v_19];
-        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_384] = [__v_15, __v_19];
+        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_381: usize = 5;
-const IN_381: usize = 5;
-const OUT_381: usize = 2;
-fn aiur_fn_381(
-  inp: [G; IN_381],
+const INPUT_SIZE_385: usize = 5;
+const IN_385: usize = 5;
+const OUT_385: usize = 2;
+fn aiur_fn_385(
+  inp: [G; IN_385],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_381], ExecError> {
+) -> Result<[G; OUT_385], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __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_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 __v_5: 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_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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_6]; 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_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 __v_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
@@ -35270,8 +35370,8 @@ fn aiur_fn_381(
         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_381] = [__v_8, __v_12];
-        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_385] = [__v_8, __v_12];
+        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -35284,11 +35384,11 @@ fn aiur_fn_381(
             let __v_11: G = __loaded[3];
             match __v_8.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_9]; 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_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 __v_12: 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_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_12, __v_13]; 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_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 __v_14: G = __r_arr[0];
                 match __v_14.as_canonical_u64() {
                   0u64 => {
@@ -35297,12 +35397,12 @@ fn aiur_fn_381(
                     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_381] = [__v_15, __v_19];
-                    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_385] = [__v_15, __v_19];
+                    record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    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_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 __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 };
@@ -35313,25 +35413,25 @@ 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_385] = [__v_18, __v_22];
+                        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
                         let __v_18: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_18]; 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_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 __v_19: G = __r_arr[0];
                         let __v_20: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_20]; 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_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 __v_21: G = __r_arr[0];
                         let __v_22: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_22]; 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_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 __v_23: G = __r_arr[0];
                         let __v_24: G = G::from_u64(3);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_24]; 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_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 __v_25: G = __r_arr[0];
                         let __v_26: G = G::from_u64(4);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 __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];
@@ -35364,10 +35464,10 @@ fn aiur_fn_381(
                                     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_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_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_50: G = __r_arr[0];
                                     let __v_51: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_50, __v_4, __v_51]; 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_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 __v_52: G = __r_arr[0];
                                     let __v_53: G = __r_arr[1];
                                     match __v_52.as_canonical_u64() {
@@ -35400,13 +35500,13 @@ fn aiur_fn_381(
                                         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_795] = { let __args: [G; IN_795] = [__v_3, __v_81]; 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_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 __v_82: G = __r_arr[0];
                                         let __v_83: G = G::from_u64(1);
-                                        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_80, __v_82]; 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_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 __v_84: G = __r_arr[0];
-                                        let __ret: [G; OUT_381] = [__v_83, __v_84];
-                                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_385] = [__v_83, __v_84];
+                                        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       0u64 => {
@@ -35415,8 +35515,8 @@ fn aiur_fn_381(
                                         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_381] = [__v_54, __v_58];
-                                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_385] = [__v_54, __v_58];
+                                        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -35430,8 +35530,8 @@ fn aiur_fn_381(
                                     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_381] = [__v_45, __v_49];
-                                    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_385] = [__v_45, __v_49];
+                                    record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -35442,8 +35542,8 @@ fn aiur_fn_381(
                                 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_381] = [__v_36, __v_40];
-                                record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_385] = [__v_36, __v_40];
+                                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -35454,8 +35554,8 @@ fn aiur_fn_381(
                             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_381] = [__v_32, __v_36];
-                            record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_385] = [__v_32, __v_36];
+                            record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -35476,8 +35576,8 @@ fn aiur_fn_381(
                 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_381] = [__v_12, __v_16];
-                record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_385] = [__v_12, __v_16];
+                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -35488,8 +35588,8 @@ fn aiur_fn_381(
             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_381] = [__v_8, __v_12];
-            record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_385] = [__v_8, __v_12];
+            record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -35501,15 +35601,15 @@ fn aiur_fn_381(
   })
 }
 
-const INPUT_SIZE_382: usize = 2;
-const IN_382: usize = 2;
-const OUT_382: usize = 5;
-fn aiur_fn_382(
-  inp: [G; IN_382],
+const INPUT_SIZE_386: usize = 2;
+const IN_386: usize = 2;
+const OUT_386: usize = 5;
+fn aiur_fn_386(
+  inp: [G; IN_386],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_382], 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];
@@ -35522,14 +35622,14 @@ fn aiur_fn_382(
       4u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_4, __v_7]; 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_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 __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_382] = [__v_8, __v_9, __v_10, __v_11, __v_12];
-        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       8u64 => {
@@ -35547,8 +35647,8 @@ fn aiur_fn_382(
                 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_382] = [__v_11, __v_1, __v_3, __v_4, __v_14];
-                record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -35557,8 +35657,8 @@ fn aiur_fn_382(
                 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_382] = [__v_11, __v_12, __v_13, __v_14, __v_15];
-                record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -35569,8 +35669,8 @@ fn aiur_fn_382(
             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_382] = [__v_10, __v_11, __v_12, __v_13, __v_14];
-            record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -35581,23 +35681,23 @@ fn aiur_fn_382(
         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_382] = [__v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_383: usize = 1;
-const IN_383: usize = 1;
-const OUT_383: usize = 1;
-fn aiur_fn_383(
-  inp: [G; IN_383],
+const INPUT_SIZE_387: usize = 1;
+const IN_387: usize = 1;
+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_383], ExecError> {
+) -> Result<[G; OUT_387], 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 };
@@ -35609,77 +35709,77 @@ fn aiur_fn_383(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 + __v_5);
-        let __ret: [G; OUT_383] = [__v_6];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_6];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_5];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_5];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_5];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_383] = [__v_7];
-        record.function_queries[383].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);
       },
       4u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__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 __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __v_7]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_383] = [__v_8];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_8];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__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 __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __v_7]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_383] = [__v_8];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_8];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3, __v_4]; 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_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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_5];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_383] = [__v_5];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_5];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35689,59 +35789,59 @@ fn aiur_fn_383(
   })
 }
 
-const INPUT_SIZE_384: usize = 3;
-const IN_384: usize = 3;
-const OUT_384: usize = 1;
-fn aiur_fn_384(
-  inp: [G; IN_384],
+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_384], 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];
     let __v_2: G = inp[2];
-    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 __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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+    let __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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3, __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 __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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+    let __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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__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 __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 __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_5, __v_7]; 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_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 __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_384] = [__v_8];
-    record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_388] = [__v_8];
+    record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_385: usize = 2;
-const IN_385: usize = 2;
-const OUT_385: usize = 1;
-fn aiur_fn_385(
-  inp: [G; IN_385],
+const INPUT_SIZE_389: usize = 2;
+const IN_389: usize = 2;
+const OUT_389: usize = 1;
+fn aiur_fn_389(
+  inp: [G; IN_389],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_385], ExecError> {
+) -> Result<[G; OUT_389], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = { 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_385] = [__v_1];
-        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_389] = [__v_1];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_385] = [__v_0];
-        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_389] = [__v_0];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35751,57 +35851,57 @@ fn aiur_fn_385(
   })
 }
 
-const INPUT_SIZE_386: usize = 1;
-const IN_386: usize = 1;
-const OUT_386: usize = 1;
-fn aiur_fn_386(
-  inp: [G; IN_386],
+const INPUT_SIZE_390: usize = 1;
+const IN_390: usize = 1;
+const OUT_390: usize = 1;
+fn aiur_fn_390(
+  inp: [G; IN_390],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_386], ExecError> {
+) -> Result<[G; OUT_390], 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_386] = [__v_1];
-        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_390] = [__v_1];
+        record.function_queries[390].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_386] = [__v_2];
-        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_390] = [__v_2];
+        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_387: usize = 2;
-const IN_387: usize = 2;
-const OUT_387: usize = 1;
-fn aiur_fn_387(
-  inp: [G; IN_387],
+const INPUT_SIZE_391: usize = 2;
+const IN_391: usize = 2;
+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_387], ExecError> {
+) -> Result<[G; OUT_391], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = { 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_387] = [__v_0];
-        record.function_queries[387].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 => {
-        let __ret: [G; OUT_387] = [__v_1];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_391] = [__v_1];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35811,15 +35911,15 @@ 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_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_388], 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];
@@ -35835,14 +35935,14 @@ fn aiur_fn_388(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_388] = [__v_8];
-            record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_392] = [__v_8];
+            record.function_queries[392].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_388] = [__v_8];
-            record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_392] = [__v_8];
+            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -35852,37 +35952,37 @@ fn aiur_fn_388(
       },
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        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 __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_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_388] = [__v_8];
-            record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_392] = [__v_8];
+            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_5, __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 __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_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_392] = [__v_8];
+            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -35891,31 +35991,31 @@ fn aiur_fn_388(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_5, __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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __v_5, __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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6, __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 __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_7: G = __r_arr[0];
-        let __ret: [G; OUT_388] = [__v_7];
-        record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -35925,27 +36025,27 @@ fn aiur_fn_388(
   })
 }
 
-const INPUT_SIZE_389: usize = 4;
-const IN_389: usize = 4;
-const OUT_389: usize = 1;
-fn aiur_fn_389(
-  inp: [G; IN_389],
+const INPUT_SIZE_393: usize = 4;
+const IN_393: usize = 4;
+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_389], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2, __v_3]; 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_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 __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_389] = [__v_5];
-        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_393] = [__v_5];
+        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -35953,10 +36053,10 @@ fn aiur_fn_389(
         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_388] = { let __args: [G; IN_388] = [__v_1, __v_6, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_389] = [__v_9];
-        record.function_queries[389].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);
       },
       _ => {
@@ -35966,38 +36066,38 @@ fn aiur_fn_389(
   })
 }
 
-const INPUT_SIZE_390: usize = 5;
-const IN_390: usize = 5;
-const OUT_390: usize = 1;
-fn aiur_fn_390(
-  inp: [G; IN_390],
+const INPUT_SIZE_394: usize = 5;
+const IN_394: usize = 5;
+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_390], ExecError> {
+) -> Result<[G; OUT_394], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __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_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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_390] = [__v_6];
-        record.function_queries[390].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 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __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_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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_390] = [__v_7];
-            record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_394] = [__v_7];
+            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36005,10 +36105,10 @@ fn aiur_fn_390(
             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_388] = { let __args: [G; IN_388] = [__v_2, __v_8, __v_10]; 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_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 __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_390] = [__v_11];
-            record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_394] = [__v_11];
+            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36023,60 +36123,60 @@ fn aiur_fn_390(
   })
 }
 
-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_395: usize = 2;
+const IN_395: usize = 2;
+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_391], ExecError> {
+) -> Result<[G; OUT_395], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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 __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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __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_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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_391] = [__v_4];
-    record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_395] = [__v_4];
+    record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_392: usize = 2;
-const IN_392: usize = 2;
-const OUT_392: usize = 1;
-fn aiur_fn_392(
-  inp: [G; IN_392],
+const INPUT_SIZE_396: usize = 2;
+const IN_396: usize = 2;
+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_392], 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 __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0]; 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_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 __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_392] = [__v_2];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_396] = [__v_2];
+        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_0, __v_2]; 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_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 __v_4: G = __r_arr[0];
         let __v_5: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } };
+        let __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 __v_6: G = __r_arr[0];
         let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_392] = [__v_7];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_396] = [__v_7];
+        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36086,15 +36186,15 @@ fn aiur_fn_392(
   })
 }
 
-const INPUT_SIZE_393: usize = 1;
-const IN_393: usize = 1;
-const OUT_393: usize = 1;
-fn aiur_fn_393(
-  inp: [G; IN_393],
+const INPUT_SIZE_397: usize = 1;
+const IN_397: usize = 1;
+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_393], ExecError> {
+) -> Result<[G; OUT_397], 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 };
@@ -36104,13 +36204,13 @@ fn aiur_fn_393(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_5]; 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_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 __v_6: G = __r_arr[0];
         let __v_7: G = (__v_4 + __v_6);
-        let __ret: [G; OUT_393] = [__v_7];
-        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_397] = [__v_7];
+        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36120,44 +36220,44 @@ fn aiur_fn_393(
   })
 }
 
-const INPUT_SIZE_394: usize = 2;
-const IN_394: usize = 2;
-const OUT_394: usize = 1;
-fn aiur_fn_394(
-  inp: [G; IN_394],
+const INPUT_SIZE_398: usize = 2;
+const IN_398: usize = 2;
+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_394], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_394] = [__v_2];
-        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_398] = [__v_2];
+        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0]; 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_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 __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_394] = [__v_2];
-            record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_398] = [__v_2];
+            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_0, __v_2]; 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_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 __v_4: G = __r_arr[0];
             let __v_5: G = (__v_1 - __v_2);
-            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_5]; 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_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 __v_6: G = __r_arr[0];
             let __v_7: G = (__v_2 + __v_6);
-            let __ret: [G; OUT_394] = [__v_7];
-            record.function_queries[394].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);
           },
           _ => {
@@ -36169,15 +36269,15 @@ 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_399: usize = 2;
+const IN_399: usize = 2;
+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_395], 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];
@@ -36186,27 +36286,27 @@ fn aiur_fn_395(
         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_395] = [__v_4];
-        record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_4];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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_395] = [__v_0];
-            record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_399] = [__v_0];
+            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+            let __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 __v_4: G = __r_arr[0];
-            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_4]; 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_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 __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_395] = [__v_5];
-            record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_399] = [__v_5];
+            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36218,40 +36318,40 @@ fn aiur_fn_395(
   })
 }
 
-const INPUT_SIZE_396: usize = 3;
-const IN_396: usize = 3;
-const OUT_396: usize = 1;
-fn aiur_fn_396(
-  inp: [G; IN_396],
+const INPUT_SIZE_400: usize = 3;
+const IN_400: usize = 3;
+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_396], ExecError> {
+) -> Result<[G; OUT_400], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_396] = [__v_0];
-        record.function_queries[396].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);
       },
       _ => {
-        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 __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 __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_396] = [__v_0];
-            record.function_queries[396].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);
           },
           1u64 => {
-            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
+            let __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 __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_396] = [__v_5];
-            record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_400] = [__v_5];
+            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36263,15 +36363,15 @@ fn aiur_fn_396(
   })
 }
 
-const INPUT_SIZE_397: usize = 3;
-const IN_397: usize = 3;
-const OUT_397: usize = 1;
-fn aiur_fn_397(
-  inp: [G; IN_397],
+const INPUT_SIZE_401: usize = 3;
+const IN_401: usize = 3;
+const OUT_401: usize = 1;
+fn aiur_fn_401(
+  inp: [G; IN_401],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_397], 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];
@@ -36283,90 +36383,90 @@ fn aiur_fn_397(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_397] = [__v_7];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_7];
+        record.function_queries[401].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_397] = [__v_9];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].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_397] = [__v_9];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        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 __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 __v_8: G = __r_arr[0];
-        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 __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 __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_397] = [__v_11];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_11];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        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 __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 __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_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 __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 __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_397] = [__v_13];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_13];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        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 __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 __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_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 __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 __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_397] = [__v_13];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_13];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_397] = [__v_7];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_7];
+        record.function_queries[401].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_397] = [__v_9];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        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 __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 __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_397] = [__v_9];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_401] = [__v_9];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36376,15 +36476,15 @@ fn aiur_fn_397(
   })
 }
 
-const INPUT_SIZE_398: usize = 3;
-const IN_398: usize = 3;
-const OUT_398: usize = 1;
-fn aiur_fn_398(
-  inp: [G; IN_398],
+const INPUT_SIZE_402: usize = 3;
+const IN_402: usize = 3;
+const OUT_402: usize = 1;
+fn aiur_fn_402(
+  inp: [G; IN_402],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_398], 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];
@@ -36395,8 +36495,8 @@ fn aiur_fn_398(
         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_398] = [__v_6];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_402] = [__v_6];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -36404,8 +36504,8 @@ fn aiur_fn_398(
         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_398] = [__v_7];
-        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_402] = [__v_7];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36415,15 +36515,15 @@ fn aiur_fn_398(
   })
 }
 
-const INPUT_SIZE_399: usize = 5;
-const IN_399: usize = 5;
-const OUT_399: usize = 1;
-fn aiur_fn_399(
-  inp: [G; IN_399],
+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_399], 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];
@@ -36431,55 +36531,55 @@ fn aiur_fn_399(
     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_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 __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 __v_6: G = __r_arr[0];
-    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 __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 __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_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 __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 __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_399] = [__v_11];
-    record.function_queries[399].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);
   })
 }
 
-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_404: usize = 3;
+const IN_404: usize = 3;
+const OUT_404: usize = 1;
+fn aiur_fn_404(
+  inp: [G; IN_404],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_400], ExecError> {
+) -> Result<[G; OUT_404], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     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_404] = [__v_0];
+        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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 __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 __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_404] = [__v_0];
+            record.function_queries[404].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_405] = { let __args: [G; IN_405] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
             let __v_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_404] = [__v_5];
+            record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36491,15 +36591,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_405: usize = 3;
+const IN_405: usize = 3;
+const OUT_405: usize = 1;
+fn aiur_fn_405(
+  inp: [G; IN_405],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_401], 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];
@@ -36514,8 +36614,8 @@ fn aiur_fn_401(
         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_401] = [__v_0];
-            record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_405] = [__v_0];
+            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -36523,8 +36623,8 @@ fn aiur_fn_401(
             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_401] = [__v_11];
-            record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_405] = [__v_11];
+            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36536,88 +36636,88 @@ fn aiur_fn_401(
         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_405] = [__v_9];
+        record.function_queries[405].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_405] = [__v_9];
+        record.function_queries[405].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_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 __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_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 __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_405] = [__v_11];
+        record.function_queries[405].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_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 __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_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 __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_405] = [__v_13];
+        record.function_queries[405].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_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 __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_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 __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_405] = [__v_13];
+        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        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_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 __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_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 __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_400] = { let __args: [G; IN_400] = [__v_6, __v_1, __v_11]; 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_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 __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_401] = [__v_13];
-        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_405] = [__v_13];
+        record.function_queries[405].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_405] = [__v_9];
+        record.function_queries[405].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_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 __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_405] = [__v_9];
+        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36627,33 +36727,33 @@ 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_406: usize = 3;
+const IN_406: usize = 3;
+const OUT_406: usize = 1;
+fn aiur_fn_406(
+  inp: [G; IN_406],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_402], 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];
     let __v_2: G = inp[2];
-    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 __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 __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_402] = [__v_0];
-        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_0];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_402] = [__v_5];
-        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_406] = [__v_5];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36663,15 +36763,15 @@ fn aiur_fn_402(
   })
 }
 
-const INPUT_SIZE_403: usize = 3;
-const IN_403: usize = 3;
-const OUT_403: usize = 1;
-fn aiur_fn_403(
-  inp: [G; IN_403],
+const INPUT_SIZE_407: usize = 3;
+const IN_407: usize = 3;
+const OUT_407: usize = 1;
+fn aiur_fn_407(
+  inp: [G; IN_407],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_403], 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];
@@ -36683,90 +36783,90 @@ fn aiur_fn_403(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_403] = [__v_7];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_7];
+        record.function_queries[407].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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_9];
+        record.function_queries[407].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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_9];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __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_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 __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_403] = [__v_11];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_11];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        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_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 __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_402] = { let __args: [G; IN_402] = [__v_5, __v_1, __v_10]; 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_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 __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_403] = [__v_13];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_13];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        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_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 __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_402] = { let __args: [G; IN_402] = [__v_5, __v_1, __v_10]; 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_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 __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_403] = [__v_13];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_13];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_403] = [__v_7];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_7];
+        record.function_queries[407].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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_9];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_6, __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_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 __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_403] = [__v_9];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_407] = [__v_9];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36776,15 +36876,15 @@ fn aiur_fn_403(
   })
 }
 
-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_408: usize = 3;
+const IN_408: usize = 3;
+const OUT_408: usize = 1;
+fn aiur_fn_408(
+  inp: [G; IN_408],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_404], 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];
@@ -36795,8 +36895,8 @@ fn aiur_fn_404(
         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_404] = [__v_6];
-        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_408] = [__v_6];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -36804,10 +36904,10 @@ fn aiur_fn_404(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_1, __v_2, __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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_404] = [__v_6];
-            record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_408] = [__v_6];
+            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -36816,8 +36916,8 @@ fn aiur_fn_404(
             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_404] = [__v_9];
-            record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_408] = [__v_9];
+            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -36829,15 +36929,15 @@ fn aiur_fn_404(
   })
 }
 
-const INPUT_SIZE_405: usize = 5;
-const IN_405: usize = 5;
-const OUT_405: usize = 1;
-fn aiur_fn_405(
-  inp: [G; IN_405],
+const INPUT_SIZE_409: usize = 5;
+const IN_409: usize = 5;
+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_405], 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];
@@ -36845,48 +36945,48 @@ fn aiur_fn_405(
     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_402] = { let __args: [G; IN_402] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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_402] = { let __args: [G; IN_402] = [__v_2, __v_3, __v_9]; 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_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 __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_405] = [__v_11];
-    record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_409] = [__v_11];
+    record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-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_410: usize = 3;
+const IN_410: usize = 3;
+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_406], 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];
     let __v_2: G = inp[2];
-    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 __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 __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_410] = [__v_0];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_1, __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_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 __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_410] = [__v_5];
+        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36896,32 +36996,32 @@ 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_411: usize = 3;
+const IN_411: usize = 3;
+const OUT_411: usize = 1;
+fn aiur_fn_411(
+  inp: [G; IN_411],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_407], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_777] = { let __args: [G; IN_777] = [__v_1, __v_4]; 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_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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_2, __v_7]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_407] = [__v_8];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_411] = [__v_8];
+        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -36929,8 +37029,8 @@ fn aiur_fn_407(
         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_407] = [__v_9];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_411] = [__v_9];
+        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -36940,15 +37040,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_412: usize = 3;
+const IN_412: usize = 3;
+const OUT_412: usize = 1;
+fn aiur_fn_412(
+  inp: [G; IN_412],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_408], 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];
@@ -36960,90 +37060,90 @@ fn aiur_fn_408(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_4, __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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_408] = [__v_7];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_7];
+        record.function_queries[412].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_408] = [__v_9];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_9];
+        record.function_queries[412].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_408] = [__v_9];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_9];
+        record.function_queries[412].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_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 __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_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 __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_408] = [__v_11];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_11];
+        record.function_queries[412].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_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 __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_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 __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_408] = [__v_13];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_13];
+        record.function_queries[412].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_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 __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_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 __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_408] = [__v_13];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_13];
+        record.function_queries[412].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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_408] = [__v_7];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_7];
+        record.function_queries[412].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_408] = [__v_9];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_9];
+        record.function_queries[412].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_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 __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_408] = [__v_9];
-        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_412] = [__v_9];
+        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37053,15 +37153,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_413: usize = 5;
+const IN_413: usize = 5;
+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_409], 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];
@@ -37069,30 +37169,30 @@ 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_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 __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_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 __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_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 __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_413] = [__v_11];
+    record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_410: usize = 2;
-const IN_410: usize = 2;
-const OUT_410: usize = 1;
-fn aiur_fn_410(
-  inp: [G; IN_410],
+const INPUT_SIZE_414: usize = 2;
+const IN_414: usize = 2;
+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_410], 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];
@@ -37102,18 +37202,18 @@ fn aiur_fn_410(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_410] = [__v_0];
-        record.function_queries[410].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 __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_410] = { let __args: [G; IN_410] = [__v_7, __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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_410] = [__v_8];
-        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_414] = [__v_8];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37123,15 +37223,15 @@ fn aiur_fn_410(
   })
 }
 
-const INPUT_SIZE_411: usize = 3;
-const IN_411: usize = 3;
-const OUT_411: usize = 3;
-fn aiur_fn_411(
-  inp: [G; IN_411],
+const INPUT_SIZE_415: usize = 3;
+const IN_415: usize = 3;
+const OUT_415: usize = 3;
+fn aiur_fn_415(
+  inp: [G; IN_415],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_411], 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];
@@ -37151,17 +37251,17 @@ fn aiur_fn_411(
           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_411] = { let __args: [G; IN_411] = [__v_5, __v_9, __v_11]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
-            let __ret: [G; OUT_411] = [__v_12, __v_13, __v_14];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_415] = [__v_12, __v_13, __v_14];
+            record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __ret: [G; OUT_411] = [__v_0, __v_2, __v_1];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_415] = [__v_0, __v_2, __v_1];
+            record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37170,23 +37270,23 @@ fn aiur_fn_411(
         }
       },
       _ => {
-        let __ret: [G; OUT_411] = [__v_0, __v_2, __v_1];
-        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_415] = [__v_0, __v_2, __v_1];
+        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_412: usize = 5;
-const IN_412: usize = 5;
-const OUT_412: usize = 1;
-fn aiur_fn_412(
-  inp: [G; IN_412],
+const INPUT_SIZE_416: usize = 5;
+const IN_416: usize = 5;
+const OUT_416: usize = 1;
+fn aiur_fn_416(
+  inp: [G; IN_416],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_412], 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];
@@ -37196,56 +37296,56 @@ fn aiur_fn_412(
     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_411] = { let __args: [G; IN_411] = [__v_1, __v_0, __v_7]; 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_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 __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_196] = { let __args: [G; IN_196] = [__v_9]; 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_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 __v_11: G = __r_arr[0];
     match __v_11.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_412] = [__v_12];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_416] = [__v_12];
+        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_9, __v_12]; 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_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 __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_13, __v_14]; 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_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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_15, __v_10, __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 __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 __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_412] = [__v_16];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_416] = [__v_16];
+        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_9, __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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_13, __v_10, __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 __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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_412] = [__v_14];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_416] = [__v_14];
+        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_417: usize = 5;
+const IN_417: usize = 5;
+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_413], 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];
@@ -37259,68 +37359,68 @@ fn aiur_fn_413(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_9, __v_11, __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 __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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_413] = [__v_12];
-        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_12];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_0, __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 __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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_413] = [__v_9];
-        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_7, __v_0, __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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_413] = [__v_9];
-        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_7, __v_9]; 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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_10, __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 __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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_413] = [__v_11];
-        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_11];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_7, __v_8, __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 __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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_413] = [__v_9];
-        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_1]; 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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_413] = [__v_9];
-        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_417] = [__v_9];
+        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_414: usize = 7;
-const IN_414: usize = 7;
-const OUT_414: usize = 1;
-fn aiur_fn_414(
-  inp: [G; IN_414],
+const INPUT_SIZE_418: usize = 7;
+const IN_418: usize = 7;
+const OUT_418: usize = 1;
+fn aiur_fn_418(
+  inp: [G; IN_418],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_414], 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];
@@ -37329,20 +37429,20 @@ fn aiur_fn_414(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_2, __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_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 __v_7: G = __r_arr[0];
-    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 __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 __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
-    let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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_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 __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_413] = { let __args: [G; IN_413] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_12];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_418] = [__v_12];
+        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -37353,7 +37453,7 @@ fn aiur_fn_414(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_13]; 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_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 __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];
@@ -37370,21 +37470,21 @@ fn aiur_fn_414(
             match __v_17.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_28]; 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_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 __v_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+                let __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 __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_414] = [__v_30];
-                record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_418] = [__v_30];
+                record.function_queries[418].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_410] = { let __args: [G; IN_410] = [__v_29, __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 __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 __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_414] = [__v_30];
-                record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_418] = [__v_30];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -37392,10 +37492,10 @@ fn aiur_fn_414(
           _ => {
             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_410] = { let __args: [G; IN_410] = [__v_17, __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 __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 __v_18: G = __r_arr[0];
-            let __ret: [G; OUT_414] = [__v_18];
-            record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_418] = [__v_18];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -37407,15 +37507,15 @@ fn aiur_fn_414(
   })
 }
 
-const INPUT_SIZE_415: usize = 5;
-const IN_415: usize = 5;
-const OUT_415: usize = 2;
-fn aiur_fn_415(
-  inp: [G; IN_415],
+const INPUT_SIZE_419: usize = 5;
+const IN_419: usize = 5;
+const OUT_419: usize = 2;
+fn aiur_fn_419(
+  inp: [G; IN_419],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_415], 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];
@@ -37429,19 +37529,19 @@ fn aiur_fn_415(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_6]; 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_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 __v_9: G = __r_arr[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_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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_10]; 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_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 __v_11: 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_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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_12]; 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_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 __v_13: 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_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_126] = { let __args: [G; IN_126] = [__v_9, __v_14]; 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_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 __v_15: G = __r_arr[0];
         let __v_16: G = (__v_13 + __v_15);
         let __v_17: G = (__v_11 + __v_16);
@@ -37452,26 +37552,26 @@ fn aiur_fn_415(
             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_415] = [__v_18, __v_22];
-            record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_419] = [__v_18, __v_22];
+            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_777] = { let __args: [G; IN_777] = [__v_1, __v_19]; 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_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 __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_20, __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_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 __v_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(1);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_22]; 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_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 __v_23: G = __r_arr[0];
-                let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_23, __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_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 __v_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_24, __v_4]; 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_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 __v_25: G = __r_arr[0];
                 let __v_26: G = __r_arr[1];
                 match __v_25.as_canonical_u64() {
@@ -37481,22 +37581,22 @@ fn aiur_fn_415(
                     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_415] = [__v_27, __v_31];
-                    record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_419] = [__v_27, __v_31];
+                    record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_26]; 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_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 __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_26]; 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_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 __v_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_28]; 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_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 __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_338] = { let __args: [G; IN_338] = [__v_21, __v_4]; 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_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 __v_32: G = __r_arr[0];
                         let __v_33: G = __r_arr[1];
                         match __v_32.as_canonical_u64() {
@@ -37506,8 +37606,8 @@ fn aiur_fn_415(
                             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_415] = [__v_34, __v_38];
-                            record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_419] = [__v_34, __v_38];
+                            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -37516,12 +37616,12 @@ fn aiur_fn_415(
                             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_340] = { let __args: [G; IN_340] = [__v_26]; 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_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 __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_415] = [__v_34, __v_41];
-                            record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_419] = [__v_34, __v_41];
+                            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -37535,8 +37635,8 @@ fn aiur_fn_415(
                         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_415] = [__v_32, __v_36];
-                        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_419] = [__v_32, __v_36];
+                        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -37552,8 +37652,8 @@ fn aiur_fn_415(
                 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_415] = [__v_19, __v_23];
-                record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_419] = [__v_19, __v_23];
+                record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -37566,23 +37666,23 @@ fn aiur_fn_415(
         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_415] = [__v_9, __v_13];
-        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_419] = [__v_9, __v_13];
+        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_416: usize = 7;
-const IN_416: usize = 7;
-const OUT_416: usize = 2;
-fn aiur_fn_416(
-  inp: [G; IN_416],
+const INPUT_SIZE_420: usize = 7;
+const IN_420: usize = 7;
+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_416], 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];
@@ -37591,58 +37691,58 @@ fn aiur_fn_416(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_416] = [__v_9, __v_8];
-        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_420] = [__v_9, __v_8];
+        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_3, __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_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 __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_416] = [__v_11, __v_10];
-            record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_420] = [__v_11, __v_10];
+            record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_416] = [__v_13, __v_12];
-                record.function_queries[416].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_353] = { let __args: [G; IN_353] = [__v_0, __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 __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 __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_416] = [__v_15, __v_14];
-                    record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_420] = [__v_15, __v_14];
+                    record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_416] = [__v_17, __v_16];
-                        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_420] = [__v_17, __v_16];
+                        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
@@ -37651,8 +37751,8 @@ fn aiur_fn_416(
                         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_416] = [__v_17, __v_21];
-                        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_420] = [__v_17, __v_21];
+                        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -37682,15 +37782,15 @@ fn aiur_fn_416(
   })
 }
 
-const INPUT_SIZE_417: usize = 7;
-const IN_417: usize = 7;
-const OUT_417: usize = 1;
-fn aiur_fn_417(
-  inp: [G; IN_417],
+const INPUT_SIZE_421: usize = 7;
+const IN_421: usize = 7;
+const OUT_421: usize = 1;
+fn aiur_fn_421(
+  inp: [G; IN_421],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_417], 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];
@@ -37699,9 +37799,9 @@ fn aiur_fn_417(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_6, __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_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 __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __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_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 __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];
@@ -37717,22 +37817,22 @@ fn aiur_fn_417(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__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[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_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 __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_424] = { let __args: [G; IN_424] = [__v_21, __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_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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_421] = [__v_22];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__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 __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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_421] = [__v_22];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37741,22 +37841,22 @@ fn aiur_fn_417(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_424] = { let __args: [G; IN_424] = [__v_21, __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_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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_421] = [__v_22];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__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 __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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_22];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_421] = [__v_22];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37765,11 +37865,11 @@ fn aiur_fn_417(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_7]; 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_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 __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_416] = { let __args: [G; IN_416] = [__v_7, __v_0, __v_1, __v_3, __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 __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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -37788,43 +37888,43 @@ fn aiur_fn_417(
         let __v_22: G = __mc_out___mc_0[1];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_22, __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_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 __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_23];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_421] = [__v_23];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_3, __v_5]; 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_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 __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_424] = { let __args: [G; IN_424] = [__v_24, __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_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 __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_417] = [__v_25];
-                record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_421] = [__v_25];
+                record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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_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 __v_25: G = __r_arr[0];
                     let __v_26: G = __r_arr[1];
                     match __v_25.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_417] = [__v_26];
-                        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_421] = [__v_26];
+                        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+                        let __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 __v_27: G = __r_arr[0];
-                        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_27, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+                        let __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 __v_28: G = __r_arr[0];
-                        let __ret: [G; OUT_417] = [__v_28];
-                        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_421] = [__v_28];
+                        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -37833,17 +37933,17 @@ fn aiur_fn_417(
                     }
                   },
                   2u64 => {
-                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__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 __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 __v_25: G = __r_arr[0];
-                    let __ret: [G; OUT_417] = [__v_25];
-                    record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_421] = [__v_25];
+                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__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 __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 __v_25: G = __r_arr[0];
-                    let __ret: [G; OUT_417] = [__v_25];
-                    record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_421] = [__v_25];
+                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -37862,15 +37962,15 @@ fn aiur_fn_417(
   })
 }
 
-const INPUT_SIZE_418: usize = 4;
-const IN_418: usize = 4;
-const OUT_418: usize = 1;
-fn aiur_fn_418(
-  inp: [G; IN_418],
+const INPUT_SIZE_422: usize = 4;
+const IN_422: usize = 4;
+const OUT_422: usize = 1;
+fn aiur_fn_422(
+  inp: [G; IN_422],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_418], 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];
@@ -37883,79 +37983,79 @@ fn aiur_fn_418(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_418] = [__v_0];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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 __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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_418] = [__v_10];
-        record.function_queries[418].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);
       },
     }
   })
 }
 
-const INPUT_SIZE_419: usize = 4;
-const IN_419: usize = 4;
-const OUT_419: usize = 1;
-fn aiur_fn_419(
-  inp: [G; IN_419],
+const INPUT_SIZE_423: usize = 4;
+const IN_423: usize = 4;
+const OUT_423: usize = 1;
+fn aiur_fn_423(
+  inp: [G; IN_423],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_419], ExecError> {
+) -> Result<[G; OUT_423], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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_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 __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_419] = [__v_6];
-    record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_423] = [__v_6];
+    record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_420: usize = 5;
-const IN_420: usize = 5;
-const OUT_420: usize = 1;
-fn aiur_fn_420(
-  inp: [G; IN_420],
+const INPUT_SIZE_424: usize = 5;
+const IN_424: usize = 5;
+const OUT_424: usize = 1;
+fn aiur_fn_424(
+  inp: [G; IN_424],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_420], 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];
@@ -37969,68 +38069,68 @@ fn aiur_fn_420(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_12];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_12];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_1, __v_0, __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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_9];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_9];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_7, __v_9]; 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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_11];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_11];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_6, __v_7, __v_8, __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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_9];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_1]; 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_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_424] = [__v_9];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_421: usize = 5;
-const IN_421: usize = 5;
-const OUT_421: usize = 1;
-fn aiur_fn_421(
-  inp: [G; IN_421],
+const INPUT_SIZE_425: usize = 5;
+const IN_425: usize = 5;
+const OUT_425: usize = 1;
+fn aiur_fn_425(
+  inp: [G; IN_425],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_421], 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];
@@ -38040,56 +38140,56 @@ fn aiur_fn_421(
     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_411] = { let __args: [G; IN_411] = [__v_1, __v_0, __v_7]; 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_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 __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_196] = { let __args: [G; IN_196] = [__v_9]; 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_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 __v_11: G = __r_arr[0];
     match __v_11.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_421] = [__v_12];
-        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_425] = [__v_12];
+        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_9, __v_12]; 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_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 __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_13, __v_14]; 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_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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_10, __v_2, __v_3, __v_4]; 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_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 __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_421] = [__v_16];
-        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_425] = [__v_16];
+        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_9, __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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_13, __v_10, __v_2, __v_3, __v_4]; 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_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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_421] = [__v_14];
-        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_425] = [__v_14];
+        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_422: usize = 7;
-const IN_422: usize = 7;
-const OUT_422: usize = 1;
-fn aiur_fn_422(
-  inp: [G; IN_422],
+const INPUT_SIZE_426: usize = 7;
+const IN_426: usize = 7;
+const OUT_426: usize = 1;
+fn aiur_fn_426(
+  inp: [G; IN_426],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_422], 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];
@@ -38098,20 +38198,20 @@ fn aiur_fn_422(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_4, __v_5, __v_6]; 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_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 __v_7: G = __r_arr[0];
-    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 __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 __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
-    let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_1, __v_8, __v_9, __v_6]; 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_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 __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_420] = { let __args: [G; IN_420] = [__v_11, __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_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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_422] = [__v_12];
-        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_426] = [__v_12];
+        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -38122,7 +38222,7 @@ fn aiur_fn_422(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_13]; 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_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 __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];
@@ -38139,21 +38239,21 @@ fn aiur_fn_422(
             match __v_17.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_28]; 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_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 __v_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_29, __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_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 __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_422] = [__v_30];
-                record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_426] = [__v_30];
+                record.function_queries[426].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_410] = { let __args: [G; IN_410] = [__v_29, __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 __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 __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_422] = [__v_30];
-                record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_426] = [__v_30];
+                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -38161,10 +38261,10 @@ fn aiur_fn_422(
           _ => {
             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_410] = { let __args: [G; IN_410] = [__v_17, __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 __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 __v_18: G = __r_arr[0];
-            let __ret: [G; OUT_422] = [__v_18];
-            record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_426] = [__v_18];
+            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38176,15 +38276,15 @@ fn aiur_fn_422(
   })
 }
 
-const INPUT_SIZE_423: usize = 7;
-const IN_423: usize = 7;
-const OUT_423: usize = 1;
-fn aiur_fn_423(
-  inp: [G; IN_423],
+const INPUT_SIZE_427: usize = 7;
+const IN_427: usize = 7;
+const OUT_427: usize = 1;
+fn aiur_fn_427(
+  inp: [G; IN_427],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_423], 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];
@@ -38193,9 +38293,9 @@ fn aiur_fn_423(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_6, __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_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 __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __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_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 __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];
@@ -38211,22 +38311,22 @@ fn aiur_fn_423(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__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[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_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 __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_418] = { let __args: [G; IN_418] = [__v_21, __v_4, __v_5, __v_6]; 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_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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_423] = [__v_22];
-            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_427] = [__v_22];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__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 __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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_423] = [__v_22];
-            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_427] = [__v_22];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38235,22 +38335,22 @@ fn aiur_fn_423(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_12, __v_3, __v_4, __v_5, __v_6]; 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_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 __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_418] = { let __args: [G; IN_418] = [__v_21, __v_4, __v_5, __v_6]; 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_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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_423] = [__v_22];
-            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_427] = [__v_22];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__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 __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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_423] = [__v_22];
-            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_427] = [__v_22];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38259,11 +38359,11 @@ fn aiur_fn_423(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_7]; 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_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 __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_416] = { let __args: [G; IN_416] = [__v_7, __v_0, __v_1, __v_3, __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 __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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     break '__mc_0 [__v_21, __v_22];
@@ -38282,29 +38382,29 @@ fn aiur_fn_423(
         let __v_22: G = __mc_out___mc_0[1];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_22, __v_4, __v_5, __v_6]; 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_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 __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_423] = [__v_23];
-            record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_427] = [__v_23];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_3, __v_5]; 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_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 __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_418] = { let __args: [G; IN_418] = [__v_24, __v_4, __v_5, __v_6]; 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_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 __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_423] = [__v_25];
-                record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_427] = [__v_25];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__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 __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 __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_423] = [__v_25];
-                record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_427] = [__v_25];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -38321,15 +38421,15 @@ fn aiur_fn_423(
   })
 }
 
-const INPUT_SIZE_424: usize = 4;
-const IN_424: usize = 4;
-const OUT_424: usize = 1;
-fn aiur_fn_424(
-  inp: [G; IN_424],
+const INPUT_SIZE_428: usize = 4;
+const IN_428: usize = 4;
+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_424], 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];
@@ -38342,79 +38442,79 @@ fn aiur_fn_424(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_424] = [__v_0];
-        record.function_queries[424].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);
       },
       7u64 => {
-        let __ret: [G; OUT_424] = [__v_0];
-        record.function_queries[424].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);
       },
       4u64 => {
-        let __ret: [G; OUT_424] = [__v_0];
-        record.function_queries[424].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);
       },
       5u64 => {
-        let __ret: [G; OUT_424] = [__v_0];
-        record.function_queries[424].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);
       },
       0u64 => {
-        let __ret: [G; OUT_424] = [__v_0];
-        record.function_queries[424].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);
       },
       _ => {
-        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 __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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_424] = [__v_10];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_428] = [__v_10];
+        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_425: usize = 4;
-const IN_425: usize = 4;
-const OUT_425: usize = 1;
-fn aiur_fn_425(
-  inp: [G; IN_425],
+const INPUT_SIZE_429: usize = 4;
+const IN_429: usize = 4;
+const OUT_429: usize = 1;
+fn aiur_fn_429(
+  inp: [G; IN_429],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_425], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_5, __v_1, __v_2, __v_3]; 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_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 __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_425] = [__v_6];
-    record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_429] = [__v_6];
+    record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_426: usize = 12;
-const IN_426: usize = 12;
-const OUT_426: usize = 2;
-fn aiur_fn_426(
-  inp: [G; IN_426],
+const INPUT_SIZE_430: usize = 12;
+const IN_430: usize = 12;
+const OUT_430: usize = 2;
+fn aiur_fn_430(
+  inp: [G; IN_430],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_426], 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];
@@ -38431,7 +38531,7 @@ fn aiur_fn_426(
     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_196] = { let __args: [G; IN_196] = [__v_1]; 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_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 __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() {
@@ -38441,21 +38541,21 @@ fn aiur_fn_426(
         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_426] = [__v_17, __v_21];
-        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_430] = [__v_17, __v_21];
+        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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_430] = { let __args: [G; IN_430] = [__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[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_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 __v_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_426] = [__v_19, __v_20];
-            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_430] = [__v_19, __v_20];
+            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38464,8 +38564,8 @@ fn aiur_fn_426(
             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_426] = [__v_19, __v_23];
-            record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_430] = [__v_19, __v_23];
+            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38477,15 +38577,15 @@ fn aiur_fn_426(
   })
 }
 
-const INPUT_SIZE_427: usize = 2;
-const IN_427: usize = 2;
-const OUT_427: usize = 1;
-fn aiur_fn_427(
-  inp: [G; IN_427],
+const INPUT_SIZE_431: usize = 2;
+const IN_431: usize = 2;
+const OUT_431: usize = 1;
+fn aiur_fn_431(
+  inp: [G; IN_431],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_427], ExecError> {
+) -> Result<[G; OUT_431], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38496,12 +38596,12 @@ fn aiur_fn_427(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       7u64 => {
-        let __ret: [G; OUT_427] = [__v_0];
-        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_431] = [__v_0];
+        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_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 };
@@ -38511,27 +38611,27 @@ fn aiur_fn_427(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_6, __v_7, __v_1]; 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_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 __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_310] = { let __args: [G; IN_310] = [__v_14]; 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_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 __v_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__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_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 __v_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_427] = [__v_0];
-                    record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_431] = [__v_0];
+                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_13, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+                    let __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 __v_17: G = __r_arr[0];
-                    let __ret: [G; OUT_427] = [__v_17];
-                    record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_431] = [__v_17];
+                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -38540,15 +38640,15 @@ fn aiur_fn_427(
                 }
               },
               _ => {
-                let __ret: [G; OUT_427] = [__v_0];
-                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_431] = [__v_0];
+                record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_427] = [__v_0];
-            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_431] = [__v_0];
+            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38557,15 +38657,15 @@ fn aiur_fn_427(
   })
 }
 
-const INPUT_SIZE_428: usize = 3;
-const IN_428: usize = 3;
-const OUT_428: usize = 3;
-fn aiur_fn_428(
-  inp: [G; IN_428],
+const INPUT_SIZE_432: usize = 3;
+const IN_432: usize = 3;
+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_428], ExecError> {
+) -> Result<[G; OUT_432], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38577,11 +38677,11 @@ fn aiur_fn_428(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_4]; 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_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 __v_7: G = __r_arr[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_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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_7, __v_8]; 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_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 __v_9: G = __r_arr[0];
         match __v_9.as_canonical_u64() {
           0u64 => {
@@ -38589,22 +38689,22 @@ fn aiur_fn_428(
             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_428] = [__v_10, __v_0, __v_13];
-            record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_432] = [__v_10, __v_0, __v_13];
+            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_777] = { let __args: [G; IN_777] = [__v_1, __v_13]; 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_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 __v_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_15]; 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_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 __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];
@@ -38616,8 +38716,8 @@ fn aiur_fn_428(
                     match __v_18.as_canonical_u64() {
                       0u64 => {
                         let __v_21: G = G::from_u64(1);
-                        let __ret: [G; OUT_428] = [__v_21, __v_14, __v_19];
-                        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_432] = [__v_21, __v_14, __v_19];
+                        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -38625,8 +38725,8 @@ fn aiur_fn_428(
                         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_428] = [__v_21, __v_0, __v_24];
-                        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_432] = [__v_21, __v_0, __v_24];
+                        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -38636,8 +38736,8 @@ fn aiur_fn_428(
                     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_428] = [__v_21, __v_0, __v_24];
-                    record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_432] = [__v_21, __v_0, __v_24];
+                    record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -38647,8 +38747,8 @@ fn aiur_fn_428(
                 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_428] = [__v_13, __v_0, __v_16];
-                record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_432] = [__v_13, __v_0, __v_16];
+                record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -38663,31 +38763,31 @@ fn aiur_fn_428(
         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_428] = [__v_7, __v_0, __v_10];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_432] = [__v_7, __v_0, __v_10];
+        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_429: usize = 3;
-const IN_429: usize = 3;
-const OUT_429: usize = 1;
-fn aiur_fn_429(
-  inp: [G; IN_429],
+const INPUT_SIZE_433: usize = 3;
+const IN_433: usize = 3;
+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_429], ExecError> {
+) -> Result<[G; OUT_433], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __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_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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __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 __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
@@ -38695,8 +38795,8 @@ fn aiur_fn_429(
         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_429] = [__v_9];
-        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_433] = [__v_9];
+        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -38713,9 +38813,9 @@ fn aiur_fn_429(
         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_311] = { let __args: [G; IN_311] = [__v_1, __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_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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_20]; 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_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 __v_21: G = __r_arr[0];
         let __v_22: G = G::from_u64(2);
         let __v_23: G = G::from_u64(1);
@@ -38723,22 +38823,22 @@ fn aiur_fn_429(
         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_321] = { let __args: [G; IN_321] = [__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_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 __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_429] = [__v_31];
-            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_433] = [__v_31];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+            let __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_29: G = __r_arr[0];
             let __v_30: G = G::from_u64(0);
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_29, __v_2, __v_30]; 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_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 __v_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
             match __v_31.as_canonical_u64() {
@@ -38746,8 +38846,8 @@ fn aiur_fn_429(
                 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_429] = [__v_35];
-                record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_433] = [__v_35];
+                record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
@@ -38770,8 +38870,8 @@ fn aiur_fn_429(
                 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_429] = [__v_51];
-                record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_433] = [__v_51];
+                record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -38791,15 +38891,15 @@ fn aiur_fn_429(
   })
 }
 
-const INPUT_SIZE_430: usize = 11;
-const IN_430: usize = 11;
-const OUT_430: usize = 2;
-fn aiur_fn_430(
-  inp: [G; IN_430],
+const INPUT_SIZE_434: usize = 11;
+const IN_434: usize = 11;
+const OUT_434: usize = 2;
+fn aiur_fn_434(
+  inp: [G; IN_434],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_430], 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];
@@ -38812,22 +38912,22 @@ fn aiur_fn_430(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__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[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_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 __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_430] = [__v_13, __v_12];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_434] = [__v_13, __v_12];
+        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_5]; 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_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 __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_439] = { let __args: [G; IN_439] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
+    let __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 __v_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
     match __v_14.as_canonical_u64() {
@@ -38851,17 +38951,17 @@ fn aiur_fn_430(
 }
  };
         let __v_14: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_14, __v_10]; 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_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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_15, __v_8, __v_9, __v_10]; 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_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 __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_16, __v_10]; 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_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 __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_17, __v_10]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_18, __v_10]; 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_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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_19]; 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_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 __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 };
@@ -38871,7 +38971,7 @@ fn aiur_fn_430(
         let __v_25: G = __loaded[3];
         match __v_22.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_9, __v_23]; 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_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 __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];
@@ -38887,7 +38987,7 @@ fn aiur_fn_430(
             let __v_37: G = __loaded[10];
             match __v_27.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_6]; 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_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 __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() {
@@ -38897,12 +38997,12 @@ fn aiur_fn_430(
                     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_430] = [__v_40, __v_44];
-                    record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_434] = [__v_40, __v_44];
+                    record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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() {
@@ -38912,12 +39012,12 @@ fn aiur_fn_430(
                         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_430] = [__v_42, __v_46];
-                        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_434] = [__v_42, __v_46];
+                        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_6, __v_31]; 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_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 __v_42: G = __r_arr[0];
                         let __v_43: G = __r_arr[1];
                         let __v_44: G = __r_arr[2];
@@ -38925,26 +39025,26 @@ fn aiur_fn_430(
                           _ => {
                             let __v_45: G = (__v_3 + __v_4);
                             let __v_46: G = (__v_2 + __v_45);
-                            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_46]; 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_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 __v_47: G = __r_arr[0];
                             let __v_48: G = (__v_40 - __v_33);
-                            let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_21, __v_48]; 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_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 __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_795] = { let __args: [G; IN_795] = [__v_1, __v_51]; 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_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 __v_52: G = __r_arr[0];
-                            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_44, __v_0]; 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_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 __v_53: G = __r_arr[0];
-                            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_53, __v_47]; 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_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 __v_54: G = __r_arr[0];
-                            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_54, __v_49]; 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_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 __v_55: G = __r_arr[0];
-                            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_55, __v_52]; 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_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 __v_56: G = __r_arr[0];
                             let __v_57: G = G::from_u64(1);
-                            let __ret: [G; OUT_430] = [__v_57, __v_56];
-                            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_434] = [__v_57, __v_56];
+                            record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -38960,21 +39060,21 @@ fn aiur_fn_430(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__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[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_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 __v_38: G = __r_arr[0];
                 let __v_39: G = __r_arr[1];
-                let __ret: [G; OUT_430] = [__v_38, __v_39];
-                record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_434] = [__v_38, __v_39];
+                record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__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[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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __ret: [G; OUT_430] = [__v_26, __v_27];
-            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_434] = [__v_26, __v_27];
+            record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38986,15 +39086,15 @@ fn aiur_fn_430(
   })
 }
 
-const INPUT_SIZE_431: usize = 8;
-const IN_431: usize = 8;
-const OUT_431: usize = 2;
-fn aiur_fn_431(
-  inp: [G; IN_431],
+const INPUT_SIZE_435: usize = 8;
+const IN_435: usize = 8;
+const OUT_435: usize = 2;
+fn aiur_fn_435(
+  inp: [G; IN_435],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_431], 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];
@@ -39013,16 +39113,16 @@ fn aiur_fn_431(
         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_431] = [__v_10, __v_14];
-        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_10, __v_14];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; 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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_10, __v_5, __v_6, __v_7]; 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_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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_7]; 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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         match __v_12.as_canonical_u64() {
@@ -39032,19 +39132,19 @@ fn aiur_fn_431(
             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_431] = [__v_14, __v_18];
-            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_435] = [__v_14, __v_18];
+            record.function_queries[435].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_777] = { let __args: [G; IN_777] = [__v_0, __v_16]; 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_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 __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_17, __v_5, __v_6, __v_7]; 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_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 __v_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_18, __v_7]; 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_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 __v_19: G = __r_arr[0];
             match __v_19.as_canonical_u64() {
               0u64 => {
@@ -39053,40 +39153,40 @@ fn aiur_fn_431(
                 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_431] = [__v_20, __v_24];
-                record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_435] = [__v_20, __v_24];
+                record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_14]; 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_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 __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_20, __v_5, __v_6, __v_7]; 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_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 __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_795] = { let __args: [G; IN_795] = [__v_0, __v_23]; 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_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 __v_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_21, __v_7]; 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_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 __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_321] = { let __args: [G; IN_321] = [__v_13]; 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_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 __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_410] = { let __args: [G; IN_410] = [__v_21, __v_24]; 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_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 __v_29: G = __r_arr[0];
-                        let __ret: [G; OUT_431] = [__v_28, __v_29];
-                        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_435] = [__v_28, __v_29];
+                        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                        let __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_28: G = __r_arr[0];
                         let __v_29: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_28, __v_7, __v_29]; 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_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 __v_30: G = __r_arr[0];
                         let __v_31: G = __r_arr[1];
                         match __v_30.as_canonical_u64() {
@@ -39096,8 +39196,8 @@ fn aiur_fn_431(
                             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_431] = [__v_32, __v_36];
-                            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_435] = [__v_32, __v_36];
+                            record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
@@ -39111,15 +39211,15 @@ fn aiur_fn_431(
                             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_340] = { let __args: [G; IN_340] = [__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_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 __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_410] = { let __args: [G; IN_410] = [__v_44, __v_24]; 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_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 __v_46: G = __r_arr[0];
-                            let __ret: [G; OUT_431] = [__v_45, __v_46];
-                            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_435] = [__v_45, __v_46];
+                            record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -39134,14 +39234,14 @@ fn aiur_fn_431(
                   },
                   1u64 => {
                     let __v_27: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                    let __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 __v_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
-                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_29, __v_24]; 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_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 __v_30: G = __r_arr[0];
-                    let __ret: [G; OUT_431] = [__v_27, __v_30];
-                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_435] = [__v_27, __v_30];
+                    record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -39166,15 +39266,15 @@ fn aiur_fn_431(
   })
 }
 
-const INPUT_SIZE_432: usize = 2;
-const IN_432: usize = 2;
-const OUT_432: usize = 1;
-fn aiur_fn_432(
-  inp: [G; IN_432],
+const INPUT_SIZE_436: usize = 2;
+const IN_436: usize = 2;
+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_432], 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];
@@ -39192,7 +39292,7 @@ fn aiur_fn_432(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; 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_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 __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 };
@@ -39202,28 +39302,28 @@ fn aiur_fn_432(
             let __v_15: G = __loaded[3];
             match __v_12.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_13]; 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_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 __v_16: 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_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_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_17]; 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_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 __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_432] = [__v_19];
-                    record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_436] = [__v_19];
+                    record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_777] = { let __args: [G; IN_777] = [__v_11, __v_22]; 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_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 __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];
@@ -39233,22 +39333,22 @@ fn aiur_fn_432(
                         match __v_24.as_canonical_u64() {
                           0u64 => {
                             let __v_28: G = G::from_bool((__v_25 == G::ZERO));
-                            let __ret: [G; OUT_432] = [__v_28];
-                            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_436] = [__v_28];
+                            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_28: G = G::from_u64(0);
-                            let __ret: [G; OUT_432] = [__v_28];
-                            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_436] = [__v_28];
+                            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_432] = [__v_22];
-                        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_436] = [__v_22];
+                        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -39260,39 +39360,39 @@ fn aiur_fn_432(
               },
               _ => {
                 let __v_16: G = G::from_u64(0);
-                let __ret: [G; OUT_432] = [__v_16];
-                record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_436] = [__v_16];
+                record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_432] = [__v_10];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_436] = [__v_10];
+            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_432] = [__v_6];
-        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_436] = [__v_6];
+        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_433: usize = 10;
-const IN_433: usize = 10;
-const OUT_433: usize = 2;
-fn aiur_fn_433(
-  inp: [G; IN_433],
+const INPUT_SIZE_437: usize = 10;
+const IN_437: usize = 10;
+const OUT_437: usize = 2;
+fn aiur_fn_437(
+  inp: [G; IN_437],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_433], 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];
@@ -39304,18 +39404,18 @@ fn aiur_fn_433(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_5]; 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_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 __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_789] = { let __args: [G; IN_789] = [__v_5, __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_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 __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_777] = { let __args: [G; IN_777] = [__v_8, __v_12]; 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_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 __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];
@@ -39331,7 +39431,7 @@ fn aiur_fn_433(
             let __v_26: G = __loaded[10];
             match __v_16.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_19]; 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_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 __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];
@@ -39347,21 +39447,21 @@ fn aiur_fn_433(
                 let __v_38: G = __loaded[10];
                 match __v_28.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_33]; 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_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 __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_514] = { let __args: [G; IN_514] = [__v_19, __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_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 __v_40: G = __r_arr[0];
                             match __v_40.as_canonical_u64() {
                               0u64 => {
-                                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; 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_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 __v_41: G = __r_arr[0];
-                                let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_41, __v_7, __v_8, __v_9]; 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_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 __v_42: G = __r_arr[0];
-                                let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_42, __v_7, __v_8, __v_9]; 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_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 __v_43: G = __r_arr[0];
                                 match __v_43.as_canonical_u64() {
                                   1u64 => {
@@ -39370,31 +39470,31 @@ fn aiur_fn_433(
                                     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_433] = [__v_44, __v_48];
-                                    record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_437] = [__v_44, __v_48];
+                                    record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_14, __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_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 __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_791] = { let __args: [G; IN_791] = [__v_0, __v_46]; 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_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 __v_47: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_44, __v_47]; 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_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 __v_48: G = __r_arr[0];
                                     let __v_49: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_48, __v_19, __v_41, __v_13, __v_49]; 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_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 __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_795] = { let __args: [G; IN_795] = [__v_0, __v_52]; 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_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 __v_53: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_50, __v_53]; 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_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 __v_54: G = __r_arr[0];
                                     let __v_55: G = G::from_u64(1);
-                                    let __ret: [G; OUT_433] = [__v_55, __v_54];
-                                    record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_437] = [__v_55, __v_54];
+                                    record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -39408,8 +39508,8 @@ fn aiur_fn_433(
                                 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_433] = [__v_41, __v_45];
-                                record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_437] = [__v_41, __v_45];
+                                record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -39420,8 +39520,8 @@ fn aiur_fn_433(
                             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_433] = [__v_40, __v_44];
-                            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_437] = [__v_40, __v_44];
+                            record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -39432,8 +39532,8 @@ fn aiur_fn_433(
                         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_433] = [__v_40, __v_44];
-                        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_437] = [__v_40, __v_44];
+                        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -39456,23 +39556,23 @@ fn aiur_fn_433(
         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_433] = [__v_11, __v_15];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_437] = [__v_11, __v_15];
+        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_434: usize = 5;
-const IN_434: usize = 5;
-const OUT_434: usize = 2;
-fn aiur_fn_434(
-  inp: [G; IN_434],
+const INPUT_SIZE_438: usize = 5;
+const IN_438: usize = 5;
+const OUT_438: usize = 2;
+fn aiur_fn_438(
+  inp: [G; IN_438],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_434], 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];
@@ -39481,19 +39581,19 @@ fn aiur_fn_434(
     let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_434] = [__v_5, __v_6];
-        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_438] = [__v_5, __v_6];
+        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } };
+        let __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 = __r_arr[1];
-        let __ret: [G; OUT_434] = [__v_5, __v_6];
-        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_438] = [__v_5, __v_6];
+        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -39502,29 +39602,29 @@ fn aiur_fn_434(
         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_434] = [__v_5, __v_9];
-        record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_438] = [__v_5, __v_9];
+        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_435: usize = 4;
-const IN_435: usize = 4;
-const OUT_435: usize = 2;
-fn aiur_fn_435(
-  inp: [G; IN_435],
+const INPUT_SIZE_439: usize = 4;
+const IN_439: usize = 4;
+const OUT_439: usize = 2;
+fn aiur_fn_439(
+  inp: [G; IN_439],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_435], ExecError> {
+) -> Result<[G; OUT_439], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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 };
@@ -39535,33 +39635,33 @@ fn aiur_fn_435(
         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_435] = [__v_7, __v_11];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_439] = [__v_7, __v_11];
+        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __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_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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(5);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_9]; 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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_10, __v_1, __v_2, __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 __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 __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_795] = { let __args: [G; IN_795] = [__v_0, __v_13]; 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_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 __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_410] = { let __args: [G; IN_410] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+            let __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 __v_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_435] = [__v_19, __v_18];
-            record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_439] = [__v_19, __v_18];
+            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -39570,8 +39670,8 @@ fn aiur_fn_435(
             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_435] = [__v_13, __v_17];
-            record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_439] = [__v_13, __v_17];
+            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -39586,21 +39686,21 @@ fn aiur_fn_435(
   })
 }
 
-const INPUT_SIZE_436: usize = 4;
-const IN_436: usize = 4;
-const OUT_436: usize = 2;
-fn aiur_fn_436(
-  inp: [G; IN_436],
+const INPUT_SIZE_440: usize = 4;
+const IN_440: usize = 4;
+const OUT_440: usize = 2;
+fn aiur_fn_440(
+  inp: [G; IN_440],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_436], 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_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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 };
@@ -39611,33 +39711,33 @@ fn aiur_fn_436(
         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_436] = [__v_7, __v_11];
-        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_440] = [__v_7, __v_11];
+        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __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_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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(4);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_9]; 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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_10, __v_1, __v_2, __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 __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 __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_795] = { let __args: [G; IN_795] = [__v_0, __v_13]; 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_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 __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_410] = { let __args: [G; IN_410] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+            let __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 __v_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_436] = [__v_19, __v_18];
-            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_440] = [__v_19, __v_18];
+            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -39646,8 +39746,8 @@ fn aiur_fn_436(
             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_436] = [__v_13, __v_17];
-            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_440] = [__v_13, __v_17];
+            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -39662,23 +39762,23 @@ fn aiur_fn_436(
   })
 }
 
-const INPUT_SIZE_437: usize = 4;
-const IN_437: usize = 4;
-const OUT_437: usize = 2;
-fn aiur_fn_437(
-  inp: [G; IN_437],
+const INPUT_SIZE_441: usize = 4;
+const IN_441: usize = 4;
+const OUT_441: usize = 2;
+fn aiur_fn_441(
+  inp: [G; IN_441],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_437], 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 __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __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_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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4]; 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_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 __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 };
@@ -39688,7 +39788,7 @@ fn aiur_fn_437(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __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_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 __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];
@@ -39706,18 +39806,18 @@ fn aiur_fn_437(
           4u64 => {
             match __v_15.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; 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_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 __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_777] = { let __args: [G; IN_777] = [__v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 __v_27: G = __r_arr[0];
                     let __v_28: G = G::from_u64(1);
-                    let __ret: [G; OUT_437] = [__v_28, __v_27];
-                    record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_441] = [__v_28, __v_27];
+                    record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -39726,8 +39826,8 @@ fn aiur_fn_437(
                     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_437] = [__v_26, __v_30];
-                    record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_441] = [__v_26, __v_30];
+                    record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -39738,8 +39838,8 @@ fn aiur_fn_437(
                 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_437] = [__v_23, __v_27];
-                record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_441] = [__v_23, __v_27];
+                record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -39750,8 +39850,8 @@ fn aiur_fn_437(
             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_437] = [__v_23, __v_27];
-            record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_441] = [__v_23, __v_27];
+            record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -39762,23 +39862,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_441] = [__v_11, __v_15];
+        record.function_queries[441].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 = 1;
-fn aiur_fn_438(
-  inp: [G; IN_438],
+const INPUT_SIZE_442: usize = 5;
+const IN_442: usize = 5;
+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_438], 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];
@@ -39788,8 +39888,8 @@ fn aiur_fn_438(
     let __v_5: G = (__v_3 - __v_4);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_438] = [__v_0];
-        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_0];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -39800,25 +39900,25 @@ fn aiur_fn_438(
         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_438] = { let __args: [G; IN_438] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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_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 __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_438] = [__v_13];
-        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_442] = [__v_13];
+        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_439: usize = 6;
-const IN_439: usize = 6;
-const OUT_439: usize = 2;
-fn aiur_fn_439(
-  inp: [G; IN_439],
+const INPUT_SIZE_443: usize = 6;
+const IN_443: usize = 6;
+const OUT_443: usize = 2;
+fn aiur_fn_443(
+  inp: [G; IN_443],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_439], 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];
@@ -39839,14 +39939,14 @@ fn aiur_fn_439(
         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_439] = [__v_11, __v_15];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_443] = [__v_11, __v_15];
+        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __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_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 __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];
@@ -39862,7 +39962,7 @@ fn aiur_fn_439(
             let __v_22: G = __loaded[10];
             match __v_12.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_15]; 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_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 __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];
@@ -39878,7 +39978,7 @@ fn aiur_fn_439(
                 let __v_34: G = __loaded[10];
                 match __v_24.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_29]; 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_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 __v_35: G = __r_arr[0];
                     match __v_35.as_canonical_u64() {
                       0u64 => {
@@ -39887,19 +39987,19 @@ fn aiur_fn_439(
                         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_439] = [__v_36, __v_40];
-                        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_443] = [__v_36, __v_40];
+                        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_36: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_29, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 __v_37: G = __r_arr[0];
-                        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_3, __v_4, __v_5]; 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_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 __v_38: G = __r_arr[0];
-                        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_38, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+                        let __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 __v_39: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_39]; 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_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 __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 };
@@ -39915,19 +40015,19 @@ fn aiur_fn_439(
                                 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_791] = { let __args: [G; IN_791] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[791].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_791] = unsafe { *(result.output.as_ptr() as *const [G; OUT_791]) }; __ret } else { aiur_fn_791(__args, record, io_buffer, __cu)? } };
+                                let __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 __v_50: G = __r_arr[0];
-                                let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_49, __v_50]; 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_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 __v_51: G = __r_arr[0];
-                                let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_51, __v_3, __v_4, __v_5]; 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_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 __v_52: G = __r_arr[0];
-                                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_39, __v_52, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
+                                let __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 __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_439] = [__v_54, __v_51];
-                                    record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_443] = [__v_54, __v_51];
+                                    record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
@@ -39936,8 +40036,8 @@ fn aiur_fn_439(
                                     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_439] = [__v_54, __v_58];
-                                    record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_443] = [__v_54, __v_58];
+                                    record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -39951,8 +40051,8 @@ fn aiur_fn_439(
                                 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_439] = [__v_47, __v_51];
-                                record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_443] = [__v_47, __v_51];
+                                record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -39963,8 +40063,8 @@ fn aiur_fn_439(
                             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_439] = [__v_46, __v_50];
-                            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_443] = [__v_46, __v_50];
+                            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -39990,15 +40090,15 @@ fn aiur_fn_439(
   })
 }
 
-const INPUT_SIZE_440: usize = 2;
-const IN_440: usize = 2;
-const OUT_440: usize = 1;
-fn aiur_fn_440(
-  inp: [G; IN_440],
+const INPUT_SIZE_444: usize = 2;
+const IN_444: usize = 2;
+const OUT_444: usize = 1;
+fn aiur_fn_444(
+  inp: [G; IN_444],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_440], 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];
@@ -40012,24 +40112,24 @@ fn aiur_fn_440(
         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_440] = [__v_8];
-        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_444] = [__v_8];
+        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_440] = [__v_3];
-            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_444] = [__v_3];
+            record.function_queries[444].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_440] = { let __args: [G; IN_440] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } };
+            let __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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_440] = [__v_7];
-            record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_444] = [__v_7];
+            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40041,15 +40141,15 @@ fn aiur_fn_440(
   })
 }
 
-const INPUT_SIZE_441: usize = 1;
-const IN_441: usize = 1;
-const OUT_441: usize = 2;
-fn aiur_fn_441(
-  inp: [G; IN_441],
+const INPUT_SIZE_445: usize = 1;
+const IN_445: usize = 1;
+const OUT_445: usize = 2;
+fn aiur_fn_445(
+  inp: [G; IN_445],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_441], ExecError> {
+) -> Result<[G; OUT_445], 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 };
@@ -40060,8 +40160,8 @@ fn aiur_fn_441(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_441] = [__v_5, __v_2];
-        record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_5, __v_2];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40069,23 +40169,23 @@ fn aiur_fn_441(
         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_441] = [__v_5, __v_8];
-        record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_445] = [__v_5, __v_8];
+        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_442: usize = 1;
-const IN_442: usize = 1;
-const OUT_442: usize = 3;
-fn aiur_fn_442(
-  inp: [G; IN_442],
+const INPUT_SIZE_446: usize = 1;
+const IN_446: usize = 1;
+const OUT_446: usize = 3;
+fn aiur_fn_446(
+  inp: [G; IN_446],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_442], ExecError> {
+) -> Result<[G; OUT_446], 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 };
@@ -40096,8 +40196,8 @@ fn aiur_fn_442(
     match __v_1.as_canonical_u64() {
       5u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_442] = [__v_5, __v_2, __v_3];
-        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_5, __v_2, __v_3];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40110,23 +40210,23 @@ fn aiur_fn_442(
         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_442] = [__v_5, __v_9, __v_13];
-        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_446] = [__v_5, __v_9, __v_13];
+        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_443: usize = 2;
-const IN_443: usize = 2;
-const OUT_443: usize = 1;
-fn aiur_fn_443(
-  inp: [G; IN_443],
+const INPUT_SIZE_447: usize = 2;
+const IN_447: usize = 2;
+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_443], 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];
@@ -40140,8 +40240,8 @@ fn aiur_fn_443(
         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_443] = [__v_8];
-        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_447] = [__v_8];
+        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -40149,23 +40249,23 @@ fn aiur_fn_443(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
+            let __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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_443] = [__v_7];
-            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_447] = [__v_7];
+            record.function_queries[447].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_443] = { let __args: [G; IN_443] = [__v_4, __v_6]; 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_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 __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_396] = { let __args: [G; IN_396] = [__v_7, __v_8, __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 __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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_443] = [__v_10];
-            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_447] = [__v_10];
+            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40177,41 +40277,41 @@ fn aiur_fn_443(
   })
 }
 
-const INPUT_SIZE_444: usize = 4;
-const IN_444: usize = 4;
-const OUT_444: usize = 1;
-fn aiur_fn_444(
-  inp: [G; IN_444],
+const INPUT_SIZE_448: usize = 4;
+const IN_448: usize = 4;
+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_444], ExecError> {
+) -> Result<[G; OUT_448], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    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 __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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } };
+    let __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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+    let __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 __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_444] = [__v_6];
-    record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_448] = [__v_6];
+    record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_445: usize = 4;
-const IN_445: usize = 4;
-const OUT_445: usize = 1;
-fn aiur_fn_445(
-  inp: [G; IN_445],
+const INPUT_SIZE_449: usize = 4;
+const IN_449: usize = 4;
+const OUT_449: usize = 1;
+fn aiur_fn_449(
+  inp: [G; IN_449],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_445], 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];
@@ -40224,10 +40324,10 @@ fn aiur_fn_445(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_445] = [__v_8];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_8];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -40235,16 +40335,16 @@ fn aiur_fn_445(
         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_228] = { let __args: [G; IN_228] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __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 __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_445] = [__v_14];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_14];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_5]; 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_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 __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];
@@ -40258,85 +40358,85 @@ fn aiur_fn_445(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; 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_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 __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 __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_455] = { let __args: [G; IN_455] = [__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[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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_22, __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_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 __v_23: G = __r_arr[0];
-        let __ret: [G; OUT_445] = [__v_23];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_23];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_8, __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 __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 __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_449] = { let __args: [G; IN_449] = [__v_10, __v_9, __v_13, __v_1, __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_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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_445] = [__v_14];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_14];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __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_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 __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_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 __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 __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_445] = [__v_14];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_14];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __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_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 __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_450] = { let __args: [G; IN_450] = [__v_6, __v_10, __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_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 __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __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 __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_445] = [__v_15];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_15];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_5, __v_6, __v_7, __v_1, __v_2, __v_3]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_445] = [__v_8];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_8];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_6, __v_3]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_445] = [__v_8];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_8];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_5, __v_6, __v_7, __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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_445] = [__v_8];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_449] = [__v_8];
+        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40346,15 +40446,15 @@ fn aiur_fn_445(
   })
 }
 
-const INPUT_SIZE_446: usize = 6;
-const IN_446: usize = 6;
-const OUT_446: usize = 1;
-fn aiur_fn_446(
-  inp: [G; IN_446],
+const INPUT_SIZE_450: usize = 6;
+const IN_450: usize = 6;
+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_446], 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];
@@ -40362,46 +40462,46 @@ fn aiur_fn_446(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __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 __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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_1, __v_0, __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 __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 __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_2, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_8, __v_3, __v_4, __v_5]; 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_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 __v_9: G = __r_arr[0];
-    let __ret: [G; OUT_446] = [__v_9];
-    record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_450] = [__v_9];
+    record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_447: usize = 3;
-const IN_447: usize = 3;
-const OUT_447: usize = 1;
-fn aiur_fn_447(
-  inp: [G; IN_447],
+const INPUT_SIZE_451: usize = 3;
+const IN_451: usize = 3;
+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_447], 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];
     let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_447] = [__v_3];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_451] = [__v_3];
+        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_447] = [__v_3];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_451] = [__v_3];
+        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -40411,15 +40511,15 @@ fn aiur_fn_447(
   })
 }
 
-const INPUT_SIZE_448: usize = 6;
-const IN_448: usize = 6;
-const OUT_448: usize = 1;
-fn aiur_fn_448(
-  inp: [G; IN_448],
+const INPUT_SIZE_452: usize = 6;
+const IN_452: usize = 6;
+const OUT_452: usize = 1;
+fn aiur_fn_452(
+  inp: [G; IN_452],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_448], 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];
@@ -40427,11 +40527,11 @@ fn aiur_fn_448(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_3, __v_4, __v_5]; 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_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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_6, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+    let __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 __v_7: G = __r_arr[0];
-    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 __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 __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 };
@@ -40441,10 +40541,7 @@ fn aiur_fn_448(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       2u64 => {
-        if (__v_11 != __v_0) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_0.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __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_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 __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];
@@ -40458,49 +40555,52 @@ fn aiur_fn_448(
         let __v_23: G = __loaded[8];
         let __v_24: G = __loaded[9];
         let __v_25: G = __loaded[10];
+        if (__v_11 != __v_0) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_0.as_canonical_u64() });
+        }
         match __v_15.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_26: G = __r_arr[0];
-            let __v_27: G = G::from_u64(1);
-            if (__v_26 != __v_27) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64() });
-            }
-            let __v_28: G = (__v_18 + __v_19);
-            let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_17, __v_12, __v_28, __v_3, __v_4, __v_5]; 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_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 __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 __v_29: G = __r_arr[0];
-            let __v_30: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_20, __v_30]; 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 __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_31]; 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 __v_32: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_33: G = __loaded[0];
-            let __v_34: G = __loaded[1];
-            let __v_35: G = __loaded[2];
-            let __v_36: G = __loaded[3];
-            let __v_37: G = __loaded[4];
-            let __v_38: G = __loaded[5];
-            let __v_39: G = __loaded[6];
-            let __v_40: G = __loaded[7];
-            let __v_41: G = __loaded[8];
-            let __v_42: G = __loaded[9];
-            let __v_43: G = __loaded[10];
-            match __v_33.as_canonical_u64() {
+            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 __v_30: G = __r_arr[0];
+            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+            let __v_31: G = __loaded[0];
+            let __v_32: G = __loaded[1];
+            let __v_33: G = __loaded[2];
+            let __v_34: G = __loaded[3];
+            let __v_35: G = __loaded[4];
+            let __v_36: G = __loaded[5];
+            let __v_37: G = __loaded[6];
+            let __v_38: G = __loaded[7];
+            let __v_39: G = __loaded[8];
+            let __v_40: G = __loaded[9];
+            let __v_41: G = __loaded[10];
+            let __r_arr: [G; OUT_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 __v_42: G = __r_arr[0];
+            let __v_43: G = G::from_u64(1);
+            if (__v_42 != __v_43) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_43.as_canonical_u64() });
+            }
+            match __v_31.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_35, __v_12]; 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_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 __v_44: G = __r_arr[0];
-                let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_44, __v_9, __v_18]; 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_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 __v_45: G = __r_arr[0];
                 let __v_46: G = G::from_u64(0);
-                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_45, __v_1, __v_46, __v_0, __v_2, __v_29, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                let __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 __v_47: G = __r_arr[0];
-                let __ret: [G; OUT_448] = [__v_47];
-                record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_452] = [__v_47];
+                record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
               },
             }
           },
@@ -40516,15 +40616,15 @@ fn aiur_fn_448(
   })
 }
 
-const INPUT_SIZE_449: usize = 6;
-const IN_449: usize = 6;
-const OUT_449: usize = 1;
-fn aiur_fn_449(
-  inp: [G; IN_449],
+const INPUT_SIZE_453: usize = 6;
+const IN_453: usize = 6;
+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_449], ExecError> {
+) -> Result<[G; OUT_453], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40539,10 +40639,10 @@ fn aiur_fn_449(
     match __v_6.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0, __v_2, __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_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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_449] = [__v_10];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_453] = [__v_10];
+        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -40554,41 +40654,41 @@ fn aiur_fn_449(
         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_10, __v_2, __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_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 __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_7, __v_14, __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 __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 __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_449] = { let __args: [G; IN_449] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; 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_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 __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_449] = [__v_17];
-            record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_453] = [__v_17];
+            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_0, __v_2, __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_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 __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+            let __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 __v_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_15]; 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_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 __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(1);
-            if (__v_16 != __v_19) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
-            }
-            let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_7, __v_17, __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_20: G = G::from_u64(0);
+            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 __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(1);
             let __v_21: G = G::from_u64(1);
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_24: G = { let __values: [G; 3] = [__v_20, __v_7, __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_449] = { let __args: [G; IN_449] = [__v_18, __v_8, __v_24, __v_3, __v_4, __v_5]; 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_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_23: G = { let __values: [G; 3] = [__v_19, __v_7, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_24: G = G::from_u64(1);
+            if (__v_16 != __v_24) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+            }
+            let __r_arr: [G; OUT_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 __v_25: G = __r_arr[0];
-            let __ret: [G; OUT_449] = [__v_25];
-            record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_453] = [__v_25];
+            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40600,21 +40700,21 @@ fn aiur_fn_449(
   })
 }
 
-const INPUT_SIZE_450: usize = 4;
-const IN_450: usize = 4;
-const OUT_450: usize = 1;
-fn aiur_fn_450(
-  inp: [G; IN_450],
+const INPUT_SIZE_454: usize = 4;
+const IN_454: usize = 4;
+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_450], ExecError> {
+) -> Result<[G; OUT_454], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __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 __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 __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];
@@ -40623,92 +40723,92 @@ fn aiur_fn_450(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_450] = [__v_6];
-        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_454] = [__v_6];
+        record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_9]; 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_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 __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_450] = [__v_11];
-        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_454] = [__v_11];
+        record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_451: usize = 5;
-const IN_451: usize = 5;
-const OUT_451: usize = 0;
-fn aiur_fn_451(
-  inp: [G; IN_451],
+const INPUT_SIZE_455: usize = 5;
+const IN_455: usize = 5;
+const OUT_455: usize = 0;
+fn aiur_fn_455(
+  inp: [G; IN_455],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_451], ExecError> {
+) -> Result<[G; OUT_455], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_2, __v_3, __v_4]; 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_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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_5, __v_1, __v_2, __v_3, __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 __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 __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_451] = [];
-    record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_455] = [];
+    record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_452: usize = 4;
-const IN_452: usize = 4;
-const OUT_452: usize = 1;
-fn aiur_fn_452(
-  inp: [G; IN_452],
+const INPUT_SIZE_456: usize = 4;
+const IN_456: usize = 4;
+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_452], ExecError> {
+) -> Result<[G; OUT_456], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    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 __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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } };
+    let __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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_5, __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_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 __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_452] = [__v_6];
-    record.function_queries[452].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);
   })
 }
 
-const INPUT_SIZE_453: usize = 4;
-const IN_453: usize = 4;
-const OUT_453: usize = 1;
-fn aiur_fn_453(
-  inp: [G; IN_453],
+const INPUT_SIZE_457: usize = 4;
+const IN_457: usize = 4;
+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_453], 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];
@@ -40721,10 +40821,10 @@ fn aiur_fn_453(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_453] = [__v_8];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_457] = [__v_8];
+        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -40732,16 +40832,16 @@ fn aiur_fn_453(
         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_228] = { let __args: [G; IN_228] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __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 __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_453] = [__v_14];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_457] = [__v_14];
+        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_5]; 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_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 __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];
@@ -40755,23 +40855,23 @@ fn aiur_fn_453(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; 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_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 __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 __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_455] = { let __args: [G; IN_455] = [__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[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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_22, __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_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 __v_23: G = __r_arr[0];
-        let __ret: [G; OUT_453] = [__v_23];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_457] = [__v_23];
+        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __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_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 __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];
@@ -40781,16 +40881,16 @@ fn aiur_fn_453(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_11, __v_6, __v_13]; 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_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 __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_453] = [__v_14];
-            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_457] = [__v_14];
+            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_8, __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_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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_13]; 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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
@@ -40799,10 +40899,10 @@ fn aiur_fn_453(
               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_402] = { let __args: [G; IN_402] = [__v_16, __v_6, __v_18]; 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_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 __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_453] = [__v_19];
-            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_457] = [__v_19];
+            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -40810,55 +40910,55 @@ fn aiur_fn_453(
       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_452] = { let __args: [G; IN_452] = [__v_6, __v_9, __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_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 __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_453] = [__v_13];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_457] = [__v_13];
+        record.function_queries[457].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_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 __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_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 __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __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 __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_453] = [__v_15];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_457] = [__v_15];
+        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_7, __v_6, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_9, __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_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 __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_457] = [__v_10];
+        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__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 __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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_453] = [__v_8];
-            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_457] = [__v_8];
+            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } };
+            let __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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_453] = [__v_8];
-            record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_457] = [__v_8];
+            record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -40867,11 +40967,11 @@ fn aiur_fn_453(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_8, __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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; 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_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 __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 };
@@ -40881,10 +40981,7 @@ fn aiur_fn_453(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            if (__v_13 != __v_5) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
-            }
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_13]; 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_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 __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];
@@ -40898,49 +40995,52 @@ fn aiur_fn_453(
             let __v_25: G = __loaded[8];
             let __v_26: G = __loaded[9];
             let __v_27: G = __loaded[10];
+            if (__v_13 != __v_5) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+            }
             match __v_17.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_22]; 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_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 = (__v_20 + __v_21);
-                let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } };
+                let __v_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 __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 __v_31: G = __r_arr[0];
-                let __v_32: G = G::from_u64(0);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_22, __v_32]; 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 __v_33: G = __r_arr[0];
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_33]; 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 __v_34: G = __r_arr[0];
-                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-                let __v_35: G = __loaded[0];
-                let __v_36: G = __loaded[1];
-                let __v_37: G = __loaded[2];
-                let __v_38: G = __loaded[3];
-                let __v_39: G = __loaded[4];
-                let __v_40: G = __loaded[5];
-                let __v_41: G = __loaded[6];
-                let __v_42: G = __loaded[7];
-                let __v_43: G = __loaded[8];
-                let __v_44: G = __loaded[9];
-                let __v_45: G = __loaded[10];
-                match __v_35.as_canonical_u64() {
+                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 __v_32: G = __r_arr[0];
+                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+                let __v_33: G = __loaded[0];
+                let __v_34: G = __loaded[1];
+                let __v_35: G = __loaded[2];
+                let __v_36: G = __loaded[3];
+                let __v_37: G = __loaded[4];
+                let __v_38: G = __loaded[5];
+                let __v_39: G = __loaded[6];
+                let __v_40: G = __loaded[7];
+                let __v_41: G = __loaded[8];
+                let __v_42: G = __loaded[9];
+                let __v_43: G = __loaded[10];
+                let __r_arr: [G; OUT_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 __v_44: G = __r_arr[0];
+                let __v_45: G = G::from_u64(1);
+                if (__v_44 != __v_45) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
+                }
+                match __v_33.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_37, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+                    let __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 __v_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_46, __v_11, __v_20]; 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_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 __v_47: G = __r_arr[0];
                     let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __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_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 __v_49: G = __r_arr[0];
-                    let __ret: [G; OUT_453] = [__v_49];
-                    record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_457] = [__v_49];
+                    record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64()));
                   },
                 }
               },
@@ -40961,21 +41061,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_458: usize = 4;
+const IN_458: usize = 4;
+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_454], 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 __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __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_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 __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];
@@ -40984,37 +41084,37 @@ 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_458] = [__v_6];
+        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_9]; 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_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 __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_458] = [__v_11];
+        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_455: usize = 11;
-const IN_455: usize = 11;
-const OUT_455: usize = 1;
-fn aiur_fn_455(
-  inp: [G; IN_455],
+const INPUT_SIZE_459: usize = 11;
+const IN_459: usize = 11;
+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_455], 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];
@@ -41029,43 +41129,43 @@ fn aiur_fn_455(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_455] = [__v_2];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_459] = [__v_2];
+        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41075,15 +41175,15 @@ fn aiur_fn_455(
   })
 }
 
-const INPUT_SIZE_456: usize = 11;
-const IN_456: usize = 11;
-const OUT_456: usize = 1;
-fn aiur_fn_456(
-  inp: [G; IN_456],
+const INPUT_SIZE_460: usize = 11;
+const IN_460: usize = 11;
+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_456], 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];
@@ -41098,43 +41198,43 @@ fn aiur_fn_456(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_456] = [__v_1];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_460] = [__v_1];
+        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41144,23 +41244,23 @@ fn aiur_fn_456(
   })
 }
 
-const INPUT_SIZE_457: usize = 3;
-const IN_457: usize = 3;
-const OUT_457: usize = 1;
-fn aiur_fn_457(
-  inp: [G; IN_457],
+const INPUT_SIZE_461: usize = 3;
+const IN_461: usize = 3;
+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_457], 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];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_457] = [__v_0];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_461] = [__v_0];
+        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41178,14 +41278,14 @@ fn aiur_fn_457(
             match __v_7.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_8, __v_10]; 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_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 __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_457] = { let __args: [G; IN_457] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+                let __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 __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_461] = [__v_14];
+                record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -41202,15 +41302,15 @@ fn aiur_fn_457(
   })
 }
 
-const INPUT_SIZE_458: usize = 9;
-const IN_458: usize = 9;
-const OUT_458: usize = 1;
-fn aiur_fn_458(
-  inp: [G; IN_458],
+const INPUT_SIZE_462: usize = 9;
+const IN_462: usize = 9;
+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_458], 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];
@@ -41231,24 +41331,24 @@ fn aiur_fn_458(
         let __v_13: G = (__v_1 - __v_2);
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_5, __v_10, __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 __ret: [G; OUT_458] = [__v_10];
-            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; 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_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 __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_402] = { let __args: [G; IN_402] = [__v_11, __v_15, __v_16]; 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_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 __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_458] = { let __args: [G; IN_458] = [__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[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_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 __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_458] = [__v_20];
-            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_462] = [__v_20];
+            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41260,15 +41360,15 @@ fn aiur_fn_458(
   })
 }
 
-const INPUT_SIZE_459: usize = 6;
-const IN_459: usize = 6;
-const OUT_459: usize = 0;
-fn aiur_fn_459(
-  inp: [G; IN_459],
+const INPUT_SIZE_463: usize = 6;
+const IN_463: usize = 6;
+const OUT_463: usize = 0;
+fn aiur_fn_463(
+  inp: [G; IN_463],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_459], 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];
@@ -41278,33 +41378,33 @@ fn aiur_fn_459(
     let __v_5: G = inp[5];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_459] = [];
-        record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_463] = [];
+        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1, __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 __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 __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_225] = { let __args: [G; IN_225] = [__v_6, __v_9]; 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_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 __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_459] = [];
-            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_463] = [];
+            record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+            let __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 __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_459] = [];
-            record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_463] = [];
+            record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41313,15 +41413,15 @@ fn aiur_fn_459(
   })
 }
 
-const INPUT_SIZE_460: usize = 5;
-const IN_460: usize = 5;
-const OUT_460: usize = 1;
-fn aiur_fn_460(
-  inp: [G; IN_460],
+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_460], 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];
@@ -41330,14 +41430,14 @@ fn aiur_fn_460(
     let __v_4: G = inp[4];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __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_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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_5];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_464] = [__v_5];
+        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __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_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 __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];
@@ -41348,15 +41448,15 @@ fn aiur_fn_460(
           5u64 => {
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_8, __v_11, __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 __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 __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_460] = [__v_12];
-            record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_464] = [__v_12];
+            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_460] = [__v_5];
-            record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_464] = [__v_5];
+            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41365,15 +41465,15 @@ fn aiur_fn_460(
   })
 }
 
-const INPUT_SIZE_461: usize = 6;
-const IN_461: usize = 6;
-const OUT_461: usize = 1;
-fn aiur_fn_461(
-  inp: [G; IN_461],
+const INPUT_SIZE_465: usize = 6;
+const IN_465: usize = 6;
+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_461], 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];
@@ -41381,9 +41481,9 @@ fn aiur_fn_461(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+    let __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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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_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 __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];
@@ -41395,31 +41495,31 @@ fn aiur_fn_461(
         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_225] = { let __args: [G; IN_225] = [__v_9, __v_14]; 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_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 __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_461] = [__v_15];
-        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_465] = [__v_15];
+        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_461] = [__v_12];
-        record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_465] = [__v_12];
+        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_462: usize = 5;
-const IN_462: usize = 5;
-const OUT_462: usize = 0;
-fn aiur_fn_462(
-  inp: [G; IN_462],
+const INPUT_SIZE_466: usize = 5;
+const IN_466: usize = 5;
+const OUT_466: usize = 0;
+fn aiur_fn_466(
+  inp: [G; IN_466],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_462], 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];
@@ -41428,45 +41528,45 @@ fn aiur_fn_462(
     let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_462] = [];
-        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_466] = [];
+        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } };
+        let __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 __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_225] = { let __args: [G; IN_225] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+        let __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 __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_462] = [];
-        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_466] = [];
+        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_463: usize = 1;
-const IN_463: usize = 1;
-const OUT_463: usize = 1;
-fn aiur_fn_463(
-  inp: [G; IN_463],
+const INPUT_SIZE_467: usize = 1;
+const IN_467: usize = 1;
+const OUT_467: usize = 1;
+fn aiur_fn_467(
+  inp: [G; IN_467],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_463], ExecError> {
+) -> Result<[G; OUT_467], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[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_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_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_1, __v_0, __v_2]; 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_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 __v_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(2);
     let __v_5: G = G::from_u64(1);
@@ -41474,27 +41574,27 @@ fn aiur_fn_463(
     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_463] = [__v_9];
-    record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_467] = [__v_9];
+    record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_464: usize = 1;
-const IN_464: usize = 1;
-const OUT_464: usize = 1;
-fn aiur_fn_464(
-  inp: [G; IN_464],
+const INPUT_SIZE_468: usize = 1;
+const IN_468: usize = 1;
+const OUT_468: usize = 1;
+fn aiur_fn_468(
+  inp: [G; IN_468],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_464], ExecError> {
+) -> Result<[G; OUT_468], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[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_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_1, __v_0, __v_2]; 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_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 __v_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(2);
     let __v_5: G = G::from_u64(1);
@@ -41502,21 +41602,21 @@ fn aiur_fn_464(
     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_464] = [__v_9];
-    record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_468] = [__v_9];
+    record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_465: usize = 3;
-const IN_465: usize = 3;
-const OUT_465: usize = 1;
-fn aiur_fn_465(
-  inp: [G; IN_465],
+const INPUT_SIZE_469: usize = 3;
+const IN_469: usize = 3;
+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_465], 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];
@@ -41527,21 +41627,21 @@ fn aiur_fn_465(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_4]; 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_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 __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_465] = [__v_2];
-            record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_469] = [__v_2];
+            record.function_queries[469].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_465] = { let __args: [G; IN_465] = [__v_0, __v_5, __v_8]; 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_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 __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_465] = [__v_9];
-            record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_469] = [__v_9];
+            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -41556,15 +41656,15 @@ fn aiur_fn_465(
   })
 }
 
-const INPUT_SIZE_466: usize = 5;
-const IN_466: usize = 5;
-const OUT_466: usize = 1;
-fn aiur_fn_466(
-  inp: [G; IN_466],
+const INPUT_SIZE_470: usize = 5;
+const IN_470: usize = 5;
+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_466], 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];
@@ -41575,38 +41675,38 @@ fn aiur_fn_466(
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_466] = [__v_6];
-        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_470] = [__v_6];
+        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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 __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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_6, __v_7]; 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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_2, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_9, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_466] = [__v_10];
-        record.function_queries[466].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);
       },
     }
   })
 }
 
-const INPUT_SIZE_467: usize = 5;
-const IN_467: usize = 5;
-const OUT_467: usize = 1;
-fn aiur_fn_467(
-  inp: [G; IN_467],
+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_467], 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];
@@ -41616,17 +41716,17 @@ fn aiur_fn_467(
     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_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __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 __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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_467] = [__v_6];
-        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_471] = [__v_6];
+        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_1, __v_0, __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 __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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_467] = [__v_6];
-        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_471] = [__v_6];
+        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -41636,152 +41736,152 @@ fn aiur_fn_467(
   })
 }
 
-const INPUT_SIZE_468: usize = 5;
-const IN_468: usize = 5;
-const OUT_468: usize = 1;
-fn aiur_fn_468(
-  inp: [G; IN_468],
+const INPUT_SIZE_472: usize = 5;
+const IN_472: usize = 5;
+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_468], ExecError> {
+) -> Result<[G; OUT_472], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __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_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 __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_468] = [__v_6];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_472] = [__v_6];
+        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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 __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_468] = [__v_7];
-            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_472] = [__v_7];
+            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __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_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 __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__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_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 __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_468] = [__v_10];
-                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_472] = [__v_10];
+                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_7, __v_8, __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 __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 __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_468] = [__v_11];
-                    record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_472] = [__v_11];
+                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+                    let __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 __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_468] = [__v_12];
-                        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_472] = [__v_12];
+                        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __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_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 __v_12: G = __r_arr[0];
-                        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__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_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 __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_468] = [__v_15];
-                            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_472] = [__v_15];
+                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_12, __v_13, __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_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 __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_468] = [__v_16];
-                                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_472] = [__v_16];
+                                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_12, __v_13, __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_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 __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_468] = [__v_17];
-                                    record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_472] = [__v_17];
+                                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   0u64 => {
-                                    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_12, __v_13, __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_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 __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_468] = [__v_18];
-                                        record.function_queries[468].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);
                                       },
                                       0u64 => {
-                                        let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_13, __v_12, __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_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 __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_468] = [__v_19];
-                                            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_472] = [__v_19];
+                                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           0u64 => {
-                                            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_12, __v_13, __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_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 __v_19: G = __r_arr[0];
                                             let __v_20: G = __r_arr[1];
                                             match __v_19.as_canonical_u64() {
                                               1u64 => {
-                                                let __ret: [G; OUT_468] = [__v_20];
-                                                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_472] = [__v_20];
+                                                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               0u64 => {
                                                 let __v_21: G = G::from_u64(16);
-                                                let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } };
+                                                let __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 __v_22: G = __r_arr[0];
                                                 let __v_23: G = __r_arr[1];
                                                 match __v_22.as_canonical_u64() {
                                                   1u64 => {
-                                                    let __ret: [G; OUT_468] = [__v_23];
-                                                    record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_472] = [__v_23];
+                                                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   0u64 => {
-                                                    let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } };
                                                     let __v_24: G = __r_arr[0];
-                                                    let __ret: [G; OUT_468] = [__v_24];
-                                                    record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_472] = [__v_24];
+                                                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -41840,15 +41940,15 @@ fn aiur_fn_468(
   })
 }
 
-const INPUT_SIZE_469: usize = 5;
-const IN_469: usize = 5;
-const OUT_469: usize = 1;
-fn aiur_fn_469(
-  inp: [G; IN_469],
+const INPUT_SIZE_473: usize = 5;
+const IN_473: usize = 5;
+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_469], 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];
@@ -41869,16 +41969,16 @@ fn aiur_fn_469(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+            let __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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_469] = [__v_13];
-            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_473] = [__v_13];
+            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_469] = [__v_13];
-            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_473] = [__v_13];
+            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41891,22 +41991,22 @@ fn aiur_fn_469(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3, __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 __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 __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_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_15, __v_3, __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 __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 __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_469] = [__v_16];
-                record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_473] = [__v_16];
+                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_469] = [__v_14];
-                record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_473] = [__v_14];
+                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -41916,8 +42016,8 @@ fn aiur_fn_469(
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_469] = [__v_13];
-            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_473] = [__v_13];
+            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -41930,22 +42030,22 @@ fn aiur_fn_469(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3, __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 __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 __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_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_15, __v_3, __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 __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 __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_469] = [__v_16];
-                record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_473] = [__v_16];
+                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_469] = [__v_14];
-                record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_473] = [__v_14];
+                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -41955,55 +42055,55 @@ fn aiur_fn_469(
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_469] = [__v_13];
-            record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_473] = [__v_13];
+            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_469] = [__v_9];
-        record.function_queries[469].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);
       },
     }
   })
 }
 
-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_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_470], 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_452] = { let __args: [G; IN_452] = [__v_0, __v_2, __v_3, __v_4]; 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_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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_5, __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 __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 __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_470] = [__v_7];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_474] = [__v_7];
+        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_1, __v_2, __v_3, __v_4]; 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_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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_5, __v_7, __v_2, __v_3, __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 __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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_470] = [__v_8];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_474] = [__v_8];
+        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42013,23 +42113,23 @@ fn aiur_fn_470(
   })
 }
 
-const INPUT_SIZE_471: usize = 4;
-const IN_471: usize = 4;
-const OUT_471: usize = 1;
-fn aiur_fn_471(
-  inp: [G; IN_471],
+const INPUT_SIZE_475: usize = 4;
+const IN_475: usize = 4;
+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_471], ExecError> {
+) -> Result<[G; OUT_475], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __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_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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __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_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 __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];
@@ -42045,63 +42145,63 @@ fn aiur_fn_471(
         match __v_10.as_canonical_u64() {
           0u64 => {
             let __v_13: G = G::from_u64(1);
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_475] = [__v_13];
+            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_471] = [__v_13];
-            record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_475] = [__v_13];
+            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_471] = [__v_10];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_475] = [__v_10];
+        record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_476: usize = 5;
+const IN_476: usize = 5;
+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_472], ExecError> {
+) -> Result<[G; OUT_476], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_2, __v_3, __v_4]; 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_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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_5, __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_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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } };
+    let __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 __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_472] = [__v_8];
-        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_476] = [__v_8];
+        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_1, __v_2, __v_3, __v_4]; 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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_5, __v_8, __v_2, __v_3, __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 __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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_472] = [__v_9];
-        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_476] = [__v_9];
+        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42111,19 +42211,19 @@ fn aiur_fn_472(
   })
 }
 
-const INPUT_SIZE_473: usize = 2;
-const IN_473: usize = 2;
-const OUT_473: usize = 1;
-fn aiur_fn_473(
-  inp: [G; IN_473],
+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_473], 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_198] = { let __args: [G; IN_198] = [__v_0]; 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_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 __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 };
@@ -42133,7 +42233,7 @@ fn aiur_fn_473(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_5]; 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_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 __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];
@@ -42149,14 +42249,14 @@ fn aiur_fn_473(
         let __v_19: G = __loaded[10];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_14]; 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_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 __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_777] = { let __args: [G; IN_777] = [__v_14, __v_21]; 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_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 __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_22]; 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_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 __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];
@@ -42175,81 +42275,81 @@ fn aiur_fn_473(
                     match __v_30.as_canonical_u64() {
                       0u64 => {
                         let __v_35: G = G::from_u64(1);
-                        let __ret: [G; OUT_473] = [__v_35];
-                        record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_477] = [__v_35];
+                        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_35: G = G::from_u64(0);
-                        let __ret: [G; OUT_473] = [__v_35];
-                        record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_477] = [__v_35];
+                        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_35: G = G::from_u64(0);
-                    let __ret: [G; OUT_473] = [__v_35];
-                    record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_477] = [__v_35];
+                    record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_21: G = G::from_u64(0);
-                let __ret: [G; OUT_473] = [__v_21];
-                record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_477] = [__v_21];
+                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_473] = [__v_20];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_477] = [__v_20];
+            record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_473] = [__v_8];
-        record.function_queries[473].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);
       },
     }
   })
 }
 
-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_478: usize = 5;
+const IN_478: usize = 5;
+const OUT_478: usize = 1;
+fn aiur_fn_478(
+  inp: [G; IN_478],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_474], ExecError> {
+) -> Result<[G; OUT_478], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_1, __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_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 __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_474] = [__v_6];
-        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_478] = [__v_6];
+        record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_0, __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_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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_474] = [__v_6];
-        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_478] = [__v_6];
+        record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -42259,15 +42359,15 @@ fn aiur_fn_474(
   })
 }
 
-const INPUT_SIZE_475: usize = 5;
-const IN_475: usize = 5;
-const OUT_475: usize = 1;
-fn aiur_fn_475(
-  inp: [G; IN_475],
+const INPUT_SIZE_479: usize = 5;
+const IN_479: usize = 5;
+const OUT_479: usize = 1;
+fn aiur_fn_479(
+  inp: [G; IN_479],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_475], 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];
@@ -42283,21 +42383,21 @@ fn aiur_fn_475(
       7u64 => {
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __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 __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_466] = { let __args: [G; IN_466] = [__v_10, __v_1, __v_2, __v_3, __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 __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 __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_475] = [__v_11];
-                record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_479] = [__v_11];
+                record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_475] = [__v_11];
-                record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_479] = [__v_11];
+                record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42307,31 +42407,31 @@ fn aiur_fn_475(
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_475] = [__v_9];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_479] = [__v_9];
+            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_475] = [__v_9];
-        record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_479] = [__v_9];
+        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_476: usize = 2;
-const IN_476: usize = 2;
-const OUT_476: usize = 1;
-fn aiur_fn_476(
-  inp: [G; IN_476],
+const INPUT_SIZE_480: usize = 2;
+const IN_480: usize = 2;
+const OUT_480: usize = 1;
+fn aiur_fn_480(
+  inp: [G; IN_480],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_476], 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];
@@ -42344,50 +42444,50 @@ fn aiur_fn_476(
       7u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4]; 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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_476] = [__v_6];
-            record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_480] = [__v_6];
+            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_476] = [__v_6];
-            record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_480] = [__v_6];
+            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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_6: 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_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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; 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_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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_476] = [__v_8];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_480] = [__v_8];
+        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_476] = [__v_6];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_480] = [__v_6];
+        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_477: usize = 2;
-const IN_477: usize = 2;
-const OUT_477: usize = 3;
-fn aiur_fn_477(
-  inp: [G; IN_477],
+const INPUT_SIZE_481: usize = 2;
+const IN_481: usize = 2;
+const OUT_481: usize = 3;
+fn aiur_fn_481(
+  inp: [G; IN_481],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_477], 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];
@@ -42404,10 +42504,10 @@ fn aiur_fn_477(
             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_340] = { let __args: [G; IN_340] = [__v_9]; 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_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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_477] = [__v_6, __v_10, __v_4];
-            record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_481] = [__v_6, __v_10, __v_4];
+            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -42415,8 +42515,8 @@ fn aiur_fn_477(
             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_477] = [__v_6, __v_0, __v_9];
-            record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_481] = [__v_6, __v_0, __v_9];
+            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42429,23 +42529,23 @@ fn aiur_fn_477(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __v_10: 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_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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_11]; 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_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 __v_12: G = __r_arr[0];
             match __v_12.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_4, __v_1]; 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_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 __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_305] = { let __args: [G; IN_305] = [__v_15]; 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_309] = { let __args: [G; IN_309] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
-                let __ret: [G; OUT_477] = [__v_16, __v_14, __v_17];
-                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_481] = [__v_16, __v_14, __v_17];
+                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
@@ -42453,8 +42553,8 @@ fn aiur_fn_477(
                 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_477] = [__v_13, __v_0, __v_16];
-                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_481] = [__v_13, __v_0, __v_16];
+                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42470,11 +42570,11 @@ fn aiur_fn_477(
             let __v_13: G = __loaded[3];
             match __v_10.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __v_14: G = __r_arr[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_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_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+                let __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 __v_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   1u64 => {
@@ -42487,23 +42587,23 @@ fn aiur_fn_477(
                       7u64 => {
                         match __v_18.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_8, __v_1]; 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_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 __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_307] = { let __args: [G; IN_307] = [__v_23, __v_19]; 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_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 __v_25: G = __r_arr[0];
-                                let __ret: [G; OUT_477] = [__v_24, __v_22, __v_25];
-                                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_481] = [__v_24, __v_22, __v_25];
+                                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_24: G = G::from_u64(1);
-                                let __ret: [G; OUT_477] = [__v_24, __v_8, __v_19];
-                                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_481] = [__v_24, __v_8, __v_19];
+                                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -42516,8 +42616,8 @@ fn aiur_fn_477(
                             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_477] = [__v_21, __v_0, __v_24];
-                            record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_481] = [__v_21, __v_0, __v_24];
+                            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -42527,8 +42627,8 @@ fn aiur_fn_477(
                         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_477] = [__v_21, __v_0, __v_24];
-                        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_481] = [__v_21, __v_0, __v_24];
+                        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -42538,8 +42638,8 @@ fn aiur_fn_477(
                     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_477] = [__v_17, __v_0, __v_20];
-                    record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_481] = [__v_17, __v_0, __v_20];
+                    record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -42552,8 +42652,8 @@ fn aiur_fn_477(
                 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_477] = [__v_14, __v_0, __v_17];
-                record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_481] = [__v_14, __v_0, __v_17];
+                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -42563,8 +42663,8 @@ fn aiur_fn_477(
             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_477] = [__v_10, __v_0, __v_13];
-            record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_481] = [__v_10, __v_0, __v_13];
+            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42574,48 +42674,48 @@ fn aiur_fn_477(
         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_477] = [__v_6, __v_0, __v_9];
-        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_481] = [__v_6, __v_0, __v_9];
+        record.function_queries[481].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 = 2;
-fn aiur_fn_478(
-  inp: [G; IN_478],
+const INPUT_SIZE_482: usize = 5;
+const IN_482: usize = 5;
+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_478], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __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_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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __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_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 __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_478] = [__v_8, __v_9];
-        record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_482] = [__v_8, __v_9];
+        record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_4]; 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_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 __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_477] = { let __args: [G; IN_477] = [__v_1, __v_4]; 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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -42624,27 +42724,27 @@ fn aiur_fn_478(
           0u64 => {
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
-            let __ret: [G; OUT_478] = [__v_15, __v_16];
-            record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_482] = [__v_15, __v_16];
+            record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10, __v_13]; 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_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 __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_478] = [__v_16, __v_17];
-                record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_482] = [__v_16, __v_17];
+                record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_9, __v_12, __v_2, __v_3, __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 __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 __v_17: G = __r_arr[0];
-                let __ret: [G; OUT_478] = [__v_16, __v_17];
-                record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_482] = [__v_16, __v_17];
+                record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -42661,22 +42761,22 @@ 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_483: usize = 5;
+const IN_483: usize = 5;
+const OUT_483: usize = 1;
+fn aiur_fn_483(
+  inp: [G; IN_483],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_479], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; 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_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 __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 };
@@ -42686,7 +42786,7 @@ fn aiur_fn_479(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __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_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 __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];
@@ -42702,13 +42802,13 @@ fn aiur_fn_479(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; 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_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 __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_777] = { let __args: [G; IN_777] = [__v_3, __v_15]; 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_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 __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];
@@ -42725,7 +42825,7 @@ fn aiur_fn_479(
                 match __v_27.as_canonical_u64() {
                   5u64 => {
                     let __v_38: G = G::from_bool((__v_31 == G::ZERO));
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_32]; 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_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 __v_39: G = __r_arr[0];
                     let __v_40: G = G::from_u64(1);
                     let __v_41: G = (__v_39 - __v_40);
@@ -42734,26 +42834,26 @@ fn aiur_fn_479(
                     match __v_43.as_canonical_u64() {
                       0u64 => {
                         let __v_44: G = G::from_u64(0);
-                        let __ret: [G; OUT_479] = [__v_44];
-                        record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_483] = [__v_44];
+                        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
-                        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_15, __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_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 __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_479] = [__v_45];
-                            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_483] = [__v_45];
+                            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
                             let __v_45: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__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[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_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 __v_46: G = __r_arr[0];
-                            let __ret: [G; OUT_479] = [__v_46];
-                            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_483] = [__v_46];
+                            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -42768,47 +42868,47 @@ fn aiur_fn_479(
                   },
                   _ => {
                     let __v_38: G = G::from_u64(0);
-                    let __ret: [G; OUT_479] = [__v_38];
-                    record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_483] = [__v_38];
+                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_26: G = G::from_u64(0);
-                let __ret: [G; OUT_479] = [__v_26];
-                record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_483] = [__v_26];
+                record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_479] = [__v_23];
-            record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_483] = [__v_23];
+            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         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_483] = [__v_11];
+        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_480: usize = 9;
-const IN_480: usize = 9;
-const OUT_480: usize = 1;
-fn aiur_fn_480(
-  inp: [G; IN_480],
+const INPUT_SIZE_484: usize = 9;
+const IN_484: usize = 9;
+const OUT_484: usize = 1;
+fn aiur_fn_484(
+  inp: [G; IN_484],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_480], 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];
@@ -42823,32 +42923,32 @@ fn aiur_fn_480(
     match __v_9.as_canonical_u64() {
       0u64 => {
         let __v_10: G = G::from_u64(1);
-        let __ret: [G; OUT_480] = [__v_10];
-        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_484] = [__v_10];
+        record.function_queries[484].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_777] = { let __args: [G; IN_777] = [__v_4, __v_12]; 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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_11, __v_13, __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 __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 __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_480] = [__v_15];
-            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_484] = [__v_15];
+            record.function_queries[484].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_480] = { let __args: [G; IN_480] = [__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[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_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 __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_480] = [__v_17];
-            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_484] = [__v_17];
+            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -42860,15 +42960,15 @@ fn aiur_fn_480(
   })
 }
 
-const INPUT_SIZE_481: usize = 5;
-const IN_481: usize = 5;
-const OUT_481: usize = 1;
-fn aiur_fn_481(
-  inp: [G; IN_481],
+const INPUT_SIZE_485: usize = 5;
+const IN_485: usize = 5;
+const OUT_485: usize = 1;
+fn aiur_fn_485(
+  inp: [G; IN_485],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_481], 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];
@@ -42889,23 +42989,23 @@ fn aiur_fn_481(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+            let __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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42922,29 +43022,29 @@ fn aiur_fn_481(
             match __v_13.as_canonical_u64() {
               0u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42960,31 +43060,31 @@ fn aiur_fn_481(
             let __v_13: G = (__v_6 - __v_10);
             match __v_13.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_7, __v_11]; 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_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 __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42997,20 +43097,20 @@ fn aiur_fn_481(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3, __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 __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 __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_2, __v_3, __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 __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 __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43019,16 +43119,16 @@ fn aiur_fn_481(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43041,22 +43141,22 @@ fn aiur_fn_481(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3, __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 __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 __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_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_15, __v_3, __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 __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 __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_481] = [__v_16];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_16];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43065,10 +43165,10 @@ fn aiur_fn_481(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_6, __v_7, __v_1, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43081,22 +43181,22 @@ fn aiur_fn_481(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3, __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 __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 __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_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_15, __v_3, __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 __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 __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_481] = [__v_16];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_16];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43105,16 +43205,16 @@ fn aiur_fn_481(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43127,26 +43227,26 @@ fn aiur_fn_481(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_10, __v_2, __v_3, __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 __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 __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_2, __v_3, __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 __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 __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_466] = { let __args: [G; IN_466] = [__v_8, __v_12, __v_16, __v_3, __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 __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 __v_17: G = __r_arr[0];
-                    let __ret: [G; OUT_481] = [__v_17];
-                    record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_485] = [__v_17];
+                    record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_15: G = G::from_u64(0);
-                    let __ret: [G; OUT_481] = [__v_15];
-                    record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_485] = [__v_15];
+                    record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -43156,8 +43256,8 @@ fn aiur_fn_481(
               },
               0u64 => {
                 let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_14];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_14];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43166,16 +43266,16 @@ fn aiur_fn_481(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43188,23 +43288,23 @@ fn aiur_fn_481(
         let __v_12: G = __loaded[3];
         match __v_9.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_7, __v_10, __v_11]; 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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43224,16 +43324,16 @@ fn aiur_fn_481(
             let __v_17: G = (__v_14 * __v_16);
             match __v_17.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_8, __v_12, __v_2, __v_3, __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 __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 __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_481] = [__v_18];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_18];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_18: G = G::from_u64(0);
-                let __ret: [G; OUT_481] = [__v_18];
-                record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_485] = [__v_18];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43242,16 +43342,16 @@ fn aiur_fn_481(
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_10, __v_11, __v_0, __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_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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_481] = [__v_13];
-            record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_485] = [__v_13];
+            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43263,15 +43363,15 @@ fn aiur_fn_481(
   })
 }
 
-const INPUT_SIZE_482: usize = 6;
-const IN_482: usize = 6;
-const OUT_482: usize = 1;
-fn aiur_fn_482(
-  inp: [G; IN_482],
+const INPUT_SIZE_486: usize = 6;
+const IN_486: usize = 6;
+const OUT_486: usize = 1;
+fn aiur_fn_486(
+  inp: [G; IN_486],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_482], 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];
@@ -43281,7 +43381,7 @@ fn aiur_fn_482(
     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_396] = { let __args: [G; IN_396] = [__v_2, __v_6, __v_7]; 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_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 __v_8: G = __r_arr[0];
     let __v_9: G = G::from_u64(0);
     let __v_10: G = G::from_u64(0);
@@ -43292,23 +43392,23 @@ fn aiur_fn_482(
     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_466] = { let __args: [G; IN_466] = [__v_1, __v_15, __v_17, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
+    let __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 __v_18: G = __r_arr[0];
-    let __ret: [G; OUT_482] = [__v_18];
-    record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_486] = [__v_18];
+    record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_483: usize = 2;
-const IN_483: usize = 2;
-const OUT_483: usize = 1;
-fn aiur_fn_483(
-  inp: [G; IN_483],
+const INPUT_SIZE_487: usize = 2;
+const IN_487: usize = 2;
+const OUT_487: usize = 1;
+fn aiur_fn_487(
+  inp: [G; IN_487],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_483], 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];
@@ -43325,14 +43425,14 @@ fn aiur_fn_483(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_483] = [__v_8];
-            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_487] = [__v_8];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_483] = [__v_8];
-            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_487] = [__v_8];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43345,25 +43445,25 @@ fn aiur_fn_483(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_483] = [__v_8];
-            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_487] = [__v_8];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_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 __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 __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_4, __v_7]; 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_487] = { let __args: [G; IN_487] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_483] = [__v_9];
-                record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_487] = [__v_9];
+                record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_483] = [__v_9];
-                record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_487] = [__v_9];
+                record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43383,25 +43483,25 @@ fn aiur_fn_483(
   })
 }
 
-const INPUT_SIZE_484: usize = 5;
-const IN_484: usize = 5;
-const OUT_484: usize = 1;
-fn aiur_fn_484(
-  inp: [G; IN_484],
+const INPUT_SIZE_488: usize = 5;
+const IN_488: usize = 5;
+const OUT_488: usize = 1;
+fn aiur_fn_488(
+  inp: [G; IN_488],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_484], ExecError> {
+) -> Result<[G; OUT_488], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; 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_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 __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 };
@@ -43421,33 +43521,33 @@ fn aiur_fn_484(
             let __v_17: G = (__v_10 - __v_14);
             match __v_17.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_11, __v_15]; 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_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 __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_484] = [__v_19];
-                    record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_488] = [__v_19];
+                    record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; 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_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 __v_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_485] = { let __args: [G; IN_485] = [__v_6, __v_8, __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_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 __v_22: G = __r_arr[0];
-                        let __ret: [G; OUT_484] = [__v_22];
-                        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_488] = [__v_22];
+                        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_484] = [__v_22];
-                        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_488] = [__v_22];
+                        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -43459,39 +43559,39 @@ fn aiur_fn_484(
               },
               _ => {
                 let __v_18: G = G::from_u64(0);
-                let __ret: [G; OUT_484] = [__v_18];
-                record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_488] = [__v_18];
+                record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_17: G = G::from_u64(0);
-            let __ret: [G; OUT_484] = [__v_17];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_488] = [__v_17];
+            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_484] = [__v_13];
-        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_488] = [__v_13];
+        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_489: usize = 5;
+const IN_489: usize = 5;
+const OUT_489: usize = 1;
+fn aiur_fn_489(
+  inp: [G; IN_489],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_485], 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];
@@ -43511,14 +43611,14 @@ fn aiur_fn_485(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(1);
-            let __ret: [G; OUT_485] = [__v_11];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_489] = [__v_11];
+            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_11];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_489] = [__v_11];
+            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -43531,25 +43631,25 @@ fn aiur_fn_485(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_485] = [__v_11];
-            record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_489] = [__v_11];
+            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_9, __v_2, __v_3, __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 __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 __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_485] = [__v_12];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_489] = [__v_12];
+                record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_7, __v_10, __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_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 __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_485] = [__v_12];
-                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_489] = [__v_12];
+                record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -43569,19 +43669,19 @@ fn aiur_fn_485(
   })
 }
 
-const INPUT_SIZE_486: usize = 2;
-const IN_486: usize = 2;
-const OUT_486: usize = 1;
-fn aiur_fn_486(
-  inp: [G; IN_486],
+const INPUT_SIZE_490: usize = 2;
+const IN_490: usize = 2;
+const OUT_490: usize = 1;
+fn aiur_fn_490(
+  inp: [G; IN_490],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_486], ExecError> {
+) -> Result<[G; OUT_490], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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];
@@ -43598,39 +43698,39 @@ fn aiur_fn_486(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_486] = [__v_14];
-        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_490] = [__v_14];
+        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_486] = [__v_14];
-        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_490] = [__v_14];
+        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_486] = [__v_14];
-        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_490] = [__v_14];
+        record.function_queries[490].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_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_487], 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];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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];
@@ -43646,33 +43746,33 @@ fn aiur_fn_487(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_487] = [__v_8];
-        record.function_queries[487].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);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_487] = [__v_14];
-        record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_491] = [__v_14];
+        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_488: usize = 2;
-const IN_488: usize = 2;
-const OUT_488: usize = 2;
-fn aiur_fn_488(
-  inp: [G; IN_488],
+const INPUT_SIZE_492: usize = 2;
+const IN_492: usize = 2;
+const OUT_492: usize = 2;
+fn aiur_fn_492(
+  inp: [G; IN_492],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_488], 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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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 __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 };
@@ -43682,7 +43782,7 @@ fn aiur_fn_488(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_5]; 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_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 __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];
@@ -43698,56 +43798,56 @@ fn aiur_fn_488(
         let __v_19: G = __loaded[10];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __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_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 __v_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_20, __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 __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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_488] = [__v_21, __v_22];
-            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_492] = [__v_21, __v_22];
+            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __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_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 __v_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_20, __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 __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 __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_488] = [__v_21, __v_22];
-            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_492] = [__v_21, __v_22];
+            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_488] = [__v_20, __v_0];
-            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_492] = [__v_20, __v_0];
+            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_488] = [__v_8, __v_0];
-        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_492] = [__v_8, __v_0];
+        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_489: usize = 2;
-const IN_489: usize = 2;
-const OUT_489: usize = 2;
-fn aiur_fn_489(
-  inp: [G; IN_489],
+const INPUT_SIZE_493: usize = 2;
+const IN_493: usize = 2;
+const OUT_493: usize = 2;
+fn aiur_fn_493(
+  inp: [G; IN_493],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_489], 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];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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 __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 };
@@ -43757,7 +43857,7 @@ fn aiur_fn_489(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       8u64 => {
-        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7, __v_1]; 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_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 __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -43765,16 +43865,16 @@ fn aiur_fn_489(
             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_410] = { let __args: [G; IN_410] = [__v_11, __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 __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 __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_489] = [__v_12, __v_13];
-            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_493] = [__v_12, __v_13];
+            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_489] = [__v_10, __v_0];
-            record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_493] = [__v_10, __v_0];
+            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -43784,23 +43884,23 @@ fn aiur_fn_489(
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_489] = [__v_8, __v_0];
-        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_493] = [__v_8, __v_0];
+        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_490: usize = 6;
-const IN_490: usize = 6;
-const OUT_490: usize = 2;
-fn aiur_fn_490(
-  inp: [G; IN_490],
+const INPUT_SIZE_494: usize = 6;
+const IN_494: usize = 6;
+const OUT_494: usize = 2;
+fn aiur_fn_494(
+  inp: [G; IN_494],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_490], 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];
@@ -43812,8 +43912,8 @@ fn aiur_fn_490(
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_490] = [__v_6, __v_7];
-        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_494] = [__v_6, __v_7];
+        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -43822,15 +43922,15 @@ fn aiur_fn_490(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_490] = [__v_7, __v_8];
-            record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_494] = [__v_7, __v_8];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; 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_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 __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 };
@@ -43847,32 +43947,32 @@ fn aiur_fn_490(
                 let __v_18: G = __loaded[3];
                 match __v_15.as_canonical_u64() {
                   2u64 => {
-                    let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__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[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_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 __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_490] = [__v_20, __v_21];
-                        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_494] = [__v_20, __v_21];
+                        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__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[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_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 __v_20: G = __r_arr[0];
                         let __v_21: G = __r_arr[1];
-                        let __ret: [G; OUT_490] = [__v_20, __v_21];
-                        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_494] = [__v_20, __v_21];
+                        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __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_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 __v_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_490] = [__v_19, __v_20];
-                    record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_494] = [__v_19, __v_20];
+                    record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -43885,18 +43985,18 @@ fn aiur_fn_490(
                 let __v_18: G = __loaded[3];
                 match __v_15.as_canonical_u64() {
                   2u64 => {
-                    let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_16, __v_0, __v_1, __v_2, __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_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 __v_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_490] = [__v_19, __v_20];
-                    record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_494] = [__v_19, __v_20];
+                    record.function_queries[494].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_490] = [__v_19, __v_20];
-                    record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_494] = [__v_19, __v_20];
+                    record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -43909,15 +44009,15 @@ fn aiur_fn_490(
   })
 }
 
-const INPUT_SIZE_491: usize = 9;
-const IN_491: usize = 9;
-const OUT_491: usize = 1;
-fn aiur_fn_491(
-  inp: [G; IN_491],
+const INPUT_SIZE_495: usize = 9;
+const IN_495: usize = 9;
+const OUT_495: usize = 1;
+fn aiur_fn_495(
+  inp: [G; IN_495],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_491], 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];
@@ -43931,33 +44031,33 @@ fn aiur_fn_491(
     let __v_9: G = (__v_0 - __v_3);
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __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_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 __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_491] = [__v_11];
-            record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_495] = [__v_11];
+            record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5]; 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_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_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_485] = { let __args: [G; IN_485] = [__v_2, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } };
+                let __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 __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_491] = [__v_14];
-                record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_495] = [__v_14];
+                record.function_queries[495].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_495] = [__v_14];
+                record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -43969,23 +44069,23 @@ fn aiur_fn_491(
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_491] = [__v_10];
-        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_495] = [__v_10];
+        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_492: usize = 8;
-const IN_492: usize = 8;
-const OUT_492: usize = 2;
-fn aiur_fn_492(
-  inp: [G; IN_492],
+const INPUT_SIZE_496: usize = 8;
+const IN_496: usize = 8;
+const OUT_496: usize = 2;
+fn aiur_fn_496(
+  inp: [G; IN_496],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_492], 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];
@@ -43995,9 +44095,9 @@ fn aiur_fn_492(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __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 __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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __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 __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 __v_9: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       0u64 => {
@@ -44005,23 +44105,23 @@ fn aiur_fn_492(
           0u64 => {
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_492] = [__v_10, __v_11];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_496] = [__v_10, __v_11];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_492] = [__v_10, __v_11];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_496] = [__v_10, __v_11];
+            record.function_queries[496].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_492] = [__v_10, __v_11];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_496] = [__v_10, __v_11];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44029,45 +44129,45 @@ fn aiur_fn_492(
       1u64 => {
         match __v_9.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_492] = [__v_10, __v_11];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_496] = [__v_10, __v_11];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
+            let __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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
+            let __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 __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_495] = { let __args: [G; IN_495] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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 __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_492] = [__v_13, __v_14];
-                record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_496] = [__v_13, __v_14];
+                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
                 let __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_496] = { let __args: [G; IN_496] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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 __v_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_492] = [__v_14, __v_15];
-                    record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_496] = [__v_14, __v_15];
+                    record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_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 __v_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_492] = [__v_14, __v_15];
-                    record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_496] = [__v_14, __v_15];
+                    record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -44083,8 +44183,8 @@ fn aiur_fn_492(
           _ => {
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_492] = [__v_10, __v_11];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_496] = [__v_10, __v_11];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44092,23 +44192,23 @@ fn aiur_fn_492(
       _ => {
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_492] = [__v_10, __v_11];
-        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_496] = [__v_10, __v_11];
+        record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_493: usize = 7;
-const IN_493: usize = 7;
-const OUT_493: usize = 2;
-fn aiur_fn_493(
-  inp: [G; IN_493],
+const INPUT_SIZE_497: usize = 7;
+const IN_497: usize = 7;
+const OUT_497: usize = 2;
+fn aiur_fn_497(
+  inp: [G; IN_497],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_493], 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];
@@ -44117,39 +44217,39 @@ fn aiur_fn_493(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+    let __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 __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_493] = [__v_8, __v_9];
-        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_497] = [__v_8, __v_9];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_2, __v_5]; 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_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 __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_424] = { let __args: [G; IN_424] = [__v_9, __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_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 __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_490] = { let __args: [G; IN_490] = [__v_1, __v_10, __v_12, __v_4, __v_5, __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_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 __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_493] = [__v_13, __v_14];
-            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_497] = [__v_13, __v_14];
+            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_493] = [__v_10, __v_11];
-            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_497] = [__v_10, __v_11];
+            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44160,23 +44260,23 @@ fn aiur_fn_493(
       _ => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_493] = [__v_8, __v_9];
-        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_497] = [__v_8, __v_9];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_494: usize = 7;
-const IN_494: usize = 7;
-const OUT_494: usize = 2;
-fn aiur_fn_494(
-  inp: [G; IN_494],
+const INPUT_SIZE_498: usize = 7;
+const IN_498: usize = 7;
+const OUT_498: usize = 2;
+fn aiur_fn_498(
+  inp: [G; IN_498],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_494], 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];
@@ -44185,39 +44285,39 @@ fn aiur_fn_494(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+    let __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 __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_494] = [__v_8, __v_9];
-        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_498] = [__v_8, __v_9];
+        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_5]; 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_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 __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_424] = { let __args: [G; IN_424] = [__v_9, __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_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 __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_490] = { let __args: [G; IN_490] = [__v_10, __v_2, __v_12, __v_4, __v_5, __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_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 __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_494] = [__v_13, __v_14];
-            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_498] = [__v_13, __v_14];
+            record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_494] = [__v_10, __v_11];
-            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_498] = [__v_10, __v_11];
+            record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44228,23 +44328,23 @@ fn aiur_fn_494(
       _ => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_494] = [__v_8, __v_9];
-        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_498] = [__v_8, __v_9];
+        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_495: usize = 6;
-const IN_495: usize = 6;
-const OUT_495: usize = 2;
-fn aiur_fn_495(
-  inp: [G; IN_495],
+const INPUT_SIZE_499: usize = 6;
+const IN_499: usize = 6;
+const OUT_499: usize = 2;
+fn aiur_fn_499(
+  inp: [G; IN_499],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_495], 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];
@@ -44252,27 +44352,27 @@ fn aiur_fn_495(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __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_492] = { let __args: [G; IN_492] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+        let __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 __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_490] = { let __args: [G; IN_490] = [__v_8, __v_1, __v_10, __v_3, __v_4, __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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_495] = [__v_11, __v_12];
-        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_499] = [__v_11, __v_12];
+        record.function_queries[499].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_495] = [__v_8, __v_9];
-        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_499] = [__v_8, __v_9];
+        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44282,15 +44382,15 @@ fn aiur_fn_495(
   })
 }
 
-const INPUT_SIZE_496: usize = 6;
-const IN_496: usize = 6;
-const OUT_496: usize = 2;
-fn aiur_fn_496(
-  inp: [G; IN_496],
+const INPUT_SIZE_500: usize = 6;
+const IN_500: usize = 6;
+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_496], 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];
@@ -44298,27 +44398,27 @@ fn aiur_fn_496(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __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_492] = { let __args: [G; IN_492] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+        let __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 __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_490] = { let __args: [G; IN_490] = [__v_0, __v_8, __v_10, __v_3, __v_4, __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_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_496] = [__v_11, __v_12];
-        record.function_queries[496].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);
       },
       0u64 => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_496] = [__v_8, __v_9];
-        record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_500] = [__v_8, __v_9];
+        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44328,15 +44428,15 @@ fn aiur_fn_496(
   })
 }
 
-const INPUT_SIZE_497: usize = 6;
-const IN_497: usize = 6;
-const OUT_497: usize = 2;
-fn aiur_fn_497(
-  inp: [G; IN_497],
+const INPUT_SIZE_501: usize = 6;
+const IN_501: usize = 6;
+const OUT_501: usize = 2;
+fn aiur_fn_501(
+  inp: [G; IN_501],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_497], 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];
@@ -44344,34 +44444,34 @@ fn aiur_fn_497(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __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_492] = { let __args: [G; IN_492] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __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_492] = { let __args: [G; IN_492] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+            let __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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+            let __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 __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_490] = { let __args: [G; IN_490] = [__v_10, __v_11, __v_13, __v_3, __v_4, __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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_497] = [__v_14, __v_15];
-            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_501] = [__v_14, __v_15];
+            record.function_queries[501].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_497] = [__v_10, __v_11];
-            record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_501] = [__v_10, __v_11];
+            record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44382,8 +44482,8 @@ fn aiur_fn_497(
       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_501] = [__v_8, __v_9];
+        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44393,15 +44493,15 @@ fn aiur_fn_497(
   })
 }
 
-const INPUT_SIZE_498: usize = 7;
-const IN_498: usize = 7;
-const OUT_498: usize = 0;
-fn aiur_fn_498(
-  inp: [G; IN_498],
+const INPUT_SIZE_502: usize = 7;
+const IN_502: usize = 7;
+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_498], 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];
@@ -44411,9 +44511,9 @@ fn aiur_fn_498(
     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_501] = { let __args: [G; IN_501] = [__v_0, __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_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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; 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_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 __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 };
@@ -44423,31 +44523,31 @@ fn aiur_fn_498(
     let __v_14: G = __loaded[3];
     match __v_11.as_canonical_u64() {
       2u64 => {
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_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 __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 __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 __v_19: G = __r_arr[0];
         if (__v_12 != __v_4) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
         }
-        let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_13, __v_5, __v_15]; 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_196] = { let __args: [G; IN_196] = [__v_10]; 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_16: G = __r_arr[0];
-        let __v_17: G = (__v_1 + __v_2);
-        if (__v_16 != __v_17) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
+        let __v_20: G = (__v_1 + __v_2);
+        if (__v_16 != __v_20) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
         }
-        let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_10, __v_1, __v_3, __v_18]; 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_795] = { let __args: [G; IN_795] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[795].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_795] = unsafe { *(result.output.as_ptr() as *const [G; OUT_795]) }; __ret } else { aiur_fn_795(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_6]; 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_19, __v_20]; 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_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 __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_498] = [];
-        record.function_queries[498].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);
       },
       _ => {
@@ -44457,20 +44557,20 @@ fn aiur_fn_498(
   })
 }
 
-const INPUT_SIZE_499: usize = 3;
-const IN_499: usize = 3;
-const OUT_499: usize = 0;
-fn aiur_fn_499(
-  inp: [G; IN_499],
+const INPUT_SIZE_503: usize = 3;
+const IN_503: usize = 3;
+const OUT_503: usize = 0;
+fn aiur_fn_503(
+  inp: [G; IN_503],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_499], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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];
@@ -44490,32 +44590,32 @@ fn aiur_fn_499(
         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_504] = { let __args: [G; IN_504] = [__v_6, __v_15, __v_18, __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 __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 __v_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__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[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 __ret: [G; OUT_499] = [];
-        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_499] = [];
-        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_503] = [];
+        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_500: usize = 10;
-const IN_500: usize = 10;
-const OUT_500: usize = 0;
-fn aiur_fn_500(
-  inp: [G; IN_500],
+const INPUT_SIZE_504: usize = 10;
+const IN_504: usize = 10;
+const OUT_504: usize = 0;
+fn aiur_fn_504(
+  inp: [G; IN_504],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_500], 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];
@@ -44533,12 +44633,12 @@ fn aiur_fn_500(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_500] = [];
-        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_504] = [];
+        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __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_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 __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];
@@ -44554,6 +44654,16 @@ fn aiur_fn_500(
         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 __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 __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)? } };
             if (__v_17 != __v_1) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
             }
@@ -44563,21 +44673,11 @@ fn aiur_fn_500(
             if (__v_19 != __v_4) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
             }
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_2, __v_16, __v_4, __v_8, __v_9]; 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_498] = { let __args: [G; IN_498] = [__v_16, __v_19, __v_5, __v_20, __v_1, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
-            let __v_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_505] = { let __args: [G; IN_505] = [__v_16, __v_19, __v_6, __v_27, __v_8, __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 __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_508] = { let __args: [G; IN_508] = [__v_16, __v_19, __v_1, __v_30, __v_8, __v_9]; 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_31: G = G::from_u64(1);
             let __v_32: G = (__v_7 + __v_31);
-            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__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[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 __ret: [G; OUT_500] = [];
-            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -44586,8 +44686,8 @@ fn aiur_fn_500(
             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_500] = [];
-            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_504] = [];
+            record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -44599,22 +44699,22 @@ fn aiur_fn_500(
   })
 }
 
-const INPUT_SIZE_501: usize = 2;
-const IN_501: usize = 2;
-const OUT_501: usize = 1;
-fn aiur_fn_501(
-  inp: [G; IN_501],
+const INPUT_SIZE_505: usize = 2;
+const IN_505: usize = 2;
+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_501], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_501] = [__v_0];
-        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_505] = [__v_0];
+        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44627,10 +44727,10 @@ fn aiur_fn_501(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __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_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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_501] = [__v_8];
-            record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_505] = [__v_8];
+            record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44642,29 +44742,29 @@ fn aiur_fn_501(
   })
 }
 
-const INPUT_SIZE_502: usize = 3;
-const IN_502: usize = 3;
-const OUT_502: usize = 0;
-fn aiur_fn_502(
-  inp: [G; IN_502],
+const INPUT_SIZE_506: usize = 3;
+const IN_506: usize = 3;
+const OUT_506: usize = 0;
+fn aiur_fn_506(
+  inp: [G; IN_506],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_502], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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_502] = [];
-        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_506] = [];
+        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44680,16 +44780,16 @@ fn aiur_fn_502(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               4u64 => {
-                if (__v_7 != __v_2) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
-                }
                 let __v_9: G = G::from_u64(1);
                 let __v_10: G = (__v_1 - __v_9);
                 let __v_11: G = G::from_u64(1);
                 let __v_12: G = (__v_2 + __v_11);
-                let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_5, __v_10, __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 __ret: [G; OUT_502] = [];
-                record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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)? } };
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -44706,15 +44806,15 @@ fn aiur_fn_502(
   })
 }
 
-const INPUT_SIZE_503: usize = 4;
-const IN_503: usize = 4;
-const OUT_503: usize = 0;
-fn aiur_fn_503(
-  inp: [G; IN_503],
+const INPUT_SIZE_507: usize = 4;
+const IN_507: usize = 4;
+const OUT_507: usize = 0;
+fn aiur_fn_507(
+  inp: [G; IN_507],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_503], 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];
@@ -44723,8 +44823,8 @@ fn aiur_fn_503(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_503] = [];
-        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_507] = [];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -44741,18 +44841,18 @@ fn aiur_fn_503(
             let __v_11: G = __loaded[3];
             match __v_8.as_canonical_u64() {
               0u64 => {
-                let __v_12: G = (__v_2 + __v_1);
-                let __v_13: G = G::from_u64(1);
-                let __v_14: G = (__v_12 - __v_13);
-                let __v_15: G = (__v_14 - __v_3);
-                if (__v_9 != __v_15) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+                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 __v_14: G = (__v_2 + __v_1);
+                let __v_15: G = G::from_u64(1);
+                let __v_16: G = (__v_14 - __v_15);
+                let __v_17: G = (__v_16 - __v_3);
+                if (__v_9 != __v_17) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
                 }
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = (__v_3 + __v_16);
-                let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_1, __v_2, __v_17]; 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_503] = [];
-                record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_507] = [];
+                record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -44769,22 +44869,22 @@ fn aiur_fn_503(
   })
 }
 
-const INPUT_SIZE_504: usize = 5;
-const IN_504: usize = 5;
-const OUT_504: usize = 1;
-fn aiur_fn_504(
-  inp: [G; IN_504],
+const INPUT_SIZE_508: usize = 5;
+const IN_508: usize = 5;
+const OUT_508: usize = 1;
+fn aiur_fn_508(
+  inp: [G; IN_508],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_504], ExecError> {
+) -> Result<[G; OUT_508], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __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_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 __v_5: G = __r_arr[0];
     match __v_1.as_canonical_u64() {
       0u64 => {
@@ -44795,8 +44895,8 @@ fn aiur_fn_504(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_504] = [__v_7];
-            record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_508] = [__v_7];
+            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44816,10 +44916,10 @@ fn aiur_fn_504(
             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_504] = { let __args: [G; IN_504] = [__v_8, __v_11, __v_13, __v_3, __v_4]; 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 __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 __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_504] = [__v_14];
-            record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_508] = [__v_14];
+            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -44831,15 +44931,15 @@ fn aiur_fn_504(
   })
 }
 
-const INPUT_SIZE_505: usize = 6;
-const IN_505: usize = 6;
-const OUT_505: usize = 0;
-fn aiur_fn_505(
-  inp: [G; IN_505],
+const INPUT_SIZE_509: usize = 6;
+const IN_509: usize = 6;
+const OUT_509: usize = 0;
+fn aiur_fn_509(
+  inp: [G; IN_509],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_505], 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];
@@ -44853,29 +44953,29 @@ fn aiur_fn_505(
     let __v_8: G = __loaded[2];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_505] = [];
-        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_509] = [];
+        record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_505] = [];
-        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_506: usize = 6;
-const IN_506: usize = 6;
-const OUT_506: usize = 0;
-fn aiur_fn_506(
-  inp: [G; IN_506],
+const INPUT_SIZE_510: usize = 6;
+const IN_510: usize = 6;
+const OUT_510: usize = 0;
+fn aiur_fn_510(
+  inp: [G; IN_510],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_506], 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];
@@ -44885,9 +44985,9 @@ fn aiur_fn_506(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_0, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_506] = [];
-        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -44902,9 +45002,9 @@ fn aiur_fn_506(
             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_506] = { let __args: [G; IN_506] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_506] = [];
-            record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -44916,15 +45016,15 @@ fn aiur_fn_506(
   })
 }
 
-const INPUT_SIZE_507: usize = 5;
-const IN_507: usize = 5;
-const OUT_507: usize = 0;
-fn aiur_fn_507(
-  inp: [G; IN_507],
+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_507], 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];
@@ -44938,39 +45038,39 @@ fn aiur_fn_507(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_6, __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 __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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_9, __v_1]; 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_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 __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 __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 3] = [__v_11, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = G::from_u64(1);
+        if (__v_10 != __v_13) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
         }
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 3] = [__v_12, __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_507] = { let __args: [G; IN_507] = [__v_7, __v_1, __v_13, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_507] = [];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_507] = [];
-        record.function_queries[507].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);
       },
     }
   })
 }
 
-const INPUT_SIZE_508: usize = 6;
-const IN_508: usize = 6;
-const OUT_508: usize = 0;
-fn aiur_fn_508(
-  inp: [G; IN_508],
+const INPUT_SIZE_512: usize = 6;
+const IN_512: usize = 6;
+const OUT_512: usize = 0;
+fn aiur_fn_512(
+  inp: [G; IN_512],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_508], 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];
@@ -44978,34 +45078,34 @@ fn aiur_fn_508(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_0, __v_1, __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 __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 __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_6, __v_8, __v_7, __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_508] = [];
-    record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_509: usize = 2;
-const IN_509: usize = 2;
-const OUT_509: usize = 1;
-fn aiur_fn_509(
-  inp: [G; IN_509],
+const INPUT_SIZE_513: usize = 2;
+const IN_513: usize = 2;
+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_509], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_509] = [__v_0];
-        record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_513] = [__v_0];
+        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45018,15 +45118,15 @@ fn aiur_fn_509(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_4, __v_7]; 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_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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_509] = [__v_8];
-            record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_513] = [__v_8];
+            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_509] = [__v_0];
-            record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_513] = [__v_0];
+            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45035,23 +45135,23 @@ fn aiur_fn_509(
   })
 }
 
-const INPUT_SIZE_510: usize = 3;
-const IN_510: usize = 3;
-const OUT_510: usize = 2;
-fn aiur_fn_510(
-  inp: [G; IN_510],
+const INPUT_SIZE_514: usize = 3;
+const IN_514: usize = 3;
+const OUT_514: usize = 2;
+fn aiur_fn_514(
+  inp: [G; IN_514],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_510], ExecError> {
+) -> Result<[G; OUT_514], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_510] = [__v_0, __v_2];
-        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_514] = [__v_0, __v_2];
+        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45066,16 +45166,16 @@ fn aiur_fn_510(
             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_510] = { let __args: [G; IN_510] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
+            let __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 __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_510] = [__v_11, __v_12];
-            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_514] = [__v_11, __v_12];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_510] = [__v_0, __v_2];
-            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_514] = [__v_0, __v_2];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45084,15 +45184,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_515: usize = 5;
+const IN_515: usize = 5;
+const OUT_515: usize = 0;
+fn aiur_fn_515(
+  inp: [G; IN_515],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_511], 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];
@@ -45106,48 +45206,48 @@ fn aiur_fn_511(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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_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 __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_511] = { let __args: [G; IN_511] = [__v_7, __v_1, __v_10, __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_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));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_511] = [];
-        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_515] = [];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_512: usize = 5;
-const IN_512: usize = 5;
-const OUT_512: usize = 0;
-fn aiur_fn_512(
-  inp: [G; IN_512],
+const INPUT_SIZE_516: usize = 5;
+const IN_516: usize = 5;
+const OUT_516: usize = 0;
+fn aiur_fn_516(
+  inp: [G; IN_516],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_512], ExecError> {
+) -> Result<[G; OUT_516], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __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_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 __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_512] = [];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_516] = [];
+        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __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_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 __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];
@@ -45156,21 +45256,21 @@ fn aiur_fn_512(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_8, __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 __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 __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 __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 __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 3] = [__v_13, __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_512] = { let __args: [G; IN_512] = [__v_9, __v_1, __v_14, __v_3, __v_4]; 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 __ret: [G; OUT_512] = [];
-            record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; 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_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 __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 };
@@ -45180,16 +45280,16 @@ fn aiur_fn_512(
             let __v_16: G = __loaded[3];
             match __v_13.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_1, __v_14]; 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_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 __v_17: G = __r_arr[0];
                 match __v_17.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_512] = [];
-                    record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_516] = [];
+                    record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_14]; 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_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 __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];
@@ -45205,19 +45305,19 @@ fn aiur_fn_512(
                     let __v_29: G = __loaded[10];
                     match __v_19.as_canonical_u64() {
                       5u64 => {
-                        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_12, __v_22]; 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_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 __v_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_30, __v_1]; 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_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 __v_31: G = __r_arr[0];
-                        let __v_32: G = G::from_u64(0);
-                        if (__v_31 != __v_32) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
+                        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 __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_519] = { let __args: [G; IN_519] = [__v_1, __v_26, __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_33: G = __r_arr[0];
-                        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_24, __v_12, __v_33, __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 __ret: [G; OUT_512] = [];
-                        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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));
                         return Ok(__ret);
                       },
                       _ => {
@@ -45226,8 +45326,8 @@ fn aiur_fn_512(
                         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_512] = [];
-                        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_516] = [];
+                        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -45243,8 +45343,8 @@ fn aiur_fn_512(
                 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_512] = [];
-                record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_516] = [];
+                record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -45255,15 +45355,15 @@ fn aiur_fn_512(
   })
 }
 
-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_517: usize = 2;
+const IN_517: usize = 2;
+const OUT_517: usize = 1;
+fn aiur_fn_517(
+  inp: [G; IN_517],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_513], 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];
@@ -45274,8 +45374,8 @@ fn aiur_fn_513(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_513] = [__v_5];
-        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_517] = [__v_5];
+        record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -45283,15 +45383,15 @@ fn aiur_fn_513(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_513] = [__v_6];
-            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_517] = [__v_6];
+            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_4, __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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_513] = [__v_6];
-            record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_517] = [__v_6];
+            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45303,19 +45403,19 @@ fn aiur_fn_513(
   })
 }
 
-const INPUT_SIZE_514: usize = 2;
-const IN_514: usize = 2;
-const OUT_514: usize = 1;
-fn aiur_fn_514(
-  inp: [G; IN_514],
+const INPUT_SIZE_518: usize = 2;
+const IN_518: usize = 2;
+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_514], ExecError> {
+) -> Result<[G; OUT_518], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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];
@@ -45331,33 +45431,33 @@ fn aiur_fn_514(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1]; 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_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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_8, __v_6, __v_14, __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 __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 __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_514] = [__v_15];
-        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_518] = [__v_15];
+        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_514] = [__v_14];
-        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_518] = [__v_14];
+        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_515: usize = 4;
-const IN_515: usize = 4;
-const OUT_515: usize = 1;
-fn aiur_fn_515(
-  inp: [G; IN_515],
+const INPUT_SIZE_519: usize = 4;
+const IN_519: usize = 4;
+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_515], 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];
@@ -45370,12 +45470,12 @@ fn aiur_fn_515(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_515] = [__v_7];
-        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_519] = [__v_7];
+        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_5]; 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_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 __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];
@@ -45391,22 +45491,22 @@ fn aiur_fn_515(
         let __v_18: G = __loaded[10];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_10, __v_1]; 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_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 __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_19, __v_2]; 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_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 __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_515] = [__v_21];
-                record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_519] = [__v_21];
+                record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_6, __v_1, __v_2, __v_3]; 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_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 __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_515] = [__v_21];
-                record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_519] = [__v_21];
+                record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45415,10 +45515,10 @@ fn aiur_fn_515(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_6, __v_1, __v_2, __v_3]; 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_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 __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_515] = [__v_19];
-            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_519] = [__v_19];
+            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45430,15 +45530,15 @@ fn aiur_fn_515(
   })
 }
 
-const INPUT_SIZE_516: usize = 2;
-const IN_516: usize = 2;
-const OUT_516: usize = 1;
-fn aiur_fn_516(
-  inp: [G; IN_516],
+const INPUT_SIZE_520: usize = 2;
+const IN_520: usize = 2;
+const OUT_520: usize = 1;
+fn aiur_fn_520(
+  inp: [G; IN_520],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_516], 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];
@@ -45449,20 +45549,20 @@ fn aiur_fn_516(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __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_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 __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_516] = [__v_7];
-            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_520] = [__v_7];
+            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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 __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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_516] = [__v_7];
-            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_520] = [__v_7];
+            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45472,23 +45572,23 @@ fn aiur_fn_516(
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_516] = [__v_6];
-        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_520] = [__v_6];
+        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_521: usize = 2;
+const IN_521: usize = 2;
+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_517], 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];
@@ -45500,38 +45600,38 @@ fn aiur_fn_517(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_517] = [__v_6];
-        record.function_queries[517].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);
       },
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_517] = [__v_6];
-        record.function_queries[517].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);
       },
       2u64 => {
-        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_1, __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 __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 __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_521] = [__v_6];
+        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __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_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 __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_517] = [__v_7];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_7];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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_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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_517] = [__v_7];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_7];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45540,20 +45640,20 @@ fn aiur_fn_517(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __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_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 __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_517] = [__v_7];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_7];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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_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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_517] = [__v_7];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_7];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45562,20 +45662,20 @@ fn aiur_fn_517(
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __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_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 __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_517] = [__v_7];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_7];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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_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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_517] = [__v_7];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_7];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45584,30 +45684,30 @@ fn aiur_fn_517(
         }
       },
       6u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __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_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 __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_517] = [__v_7];
-            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_521] = [__v_7];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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_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 __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_517] = [__v_8];
-                record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_521] = [__v_8];
+                record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __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_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 __v_8: G = __r_arr[0];
-                let __ret: [G; OUT_517] = [__v_8];
-                record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_521] = [__v_8];
+                record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45622,15 +45722,15 @@ fn aiur_fn_517(
       },
       7u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_517] = [__v_6];
-        record.function_queries[517].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);
       },
       8u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __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_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 __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_521] = [__v_6];
+        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -45640,15 +45740,15 @@ 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_522: usize = 2;
+const IN_522: usize = 2;
+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_518], 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];
@@ -45659,25 +45759,25 @@ fn aiur_fn_518(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_518] = [__v_5];
-        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_522] = [__v_5];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_3, __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_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 __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_518] = [__v_6];
-            record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_522] = [__v_6];
+            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_4, __v_1]; 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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_518] = [__v_6];
-            record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_522] = [__v_6];
+            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -45692,37 +45792,37 @@ fn aiur_fn_518(
   })
 }
 
-const INPUT_SIZE_519: usize = 3;
-const IN_519: usize = 3;
-const OUT_519: usize = 1;
-fn aiur_fn_519(
-  inp: [G; IN_519],
+const INPUT_SIZE_523: usize = 3;
+const IN_523: usize = 3;
+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_519], 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 __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_3]; 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_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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_519] = [__v_4];
-    record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_523] = [__v_4];
+    record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_520: usize = 4;
-const IN_520: usize = 4;
-const OUT_520: usize = 1;
-fn aiur_fn_520(
-  inp: [G; IN_520],
+const INPUT_SIZE_524: usize = 4;
+const IN_524: usize = 4;
+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_520], 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];
@@ -45734,8 +45834,8 @@ fn aiur_fn_520(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_520] = [__v_0];
-        record.function_queries[520].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);
       },
       0u64 => {
@@ -45753,7 +45853,7 @@ fn aiur_fn_520(
         let __v_17: G = __loaded[10];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_14, __v_1]; 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_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 __v_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(1);
             let __v_20: G = G::from_u64(0);
@@ -45789,10 +45889,10 @@ fn aiur_fn_520(
             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_126] = { let __args: [G; IN_126] = [__v_1, __v_52]; 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_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 __v_53: G = __r_arr[0];
             let __v_54: G = (__v_19 - __v_53);
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __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 __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 __v_55: G = __r_arr[0];
             let __v_56: G = G::from_u64(1);
             let __v_57: G = (__v_56 - __v_55);
@@ -45804,19 +45904,19 @@ fn aiur_fn_520(
                 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_520] = { let __args: [G; IN_520] = [__v_61, __v_1, __v_6, __v_63]; 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_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 __v_64: G = __r_arr[0];
-                let __ret: [G; OUT_520] = [__v_64];
-                record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_524] = [__v_64];
+                record.function_queries[524].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_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_6, __v_61]; 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_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 __v_62: G = __r_arr[0];
-                let __ret: [G; OUT_520] = [__v_62];
-                record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_524] = [__v_62];
+                record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -45827,10 +45927,10 @@ fn aiur_fn_520(
           _ => {
             let __v_18: G = G::from_u64(1);
             let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_6, __v_19]; 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_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 __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_520] = [__v_20];
-            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_524] = [__v_20];
+            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -45842,15 +45942,15 @@ fn aiur_fn_520(
   })
 }
 
-const INPUT_SIZE_521: usize = 5;
-const IN_521: usize = 5;
-const OUT_521: usize = 0;
-fn aiur_fn_521(
-  inp: [G; IN_521],
+const INPUT_SIZE_525: usize = 5;
+const IN_525: usize = 5;
+const OUT_525: usize = 0;
+fn aiur_fn_525(
+  inp: [G; IN_525],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_521], 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];
@@ -45863,12 +45963,12 @@ fn aiur_fn_521(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_521] = [];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_525] = [];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_6]; 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_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 __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];
@@ -45887,19 +45987,19 @@ fn aiur_fn_521(
             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_510] = { let __args: [G; IN_510] = [__v_11, __v_14, __v_22]; 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 __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 __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
-            let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_23, __v_2, __v_24, __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 __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_7, __v_1, __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 __ret: [G; OUT_521] = [];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_7, __v_1, __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 __ret: [G; OUT_521] = [];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -45911,15 +46011,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_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_522], 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];
@@ -45931,14 +46031,14 @@ fn aiur_fn_522(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_522] = [__v_6];
-        record.function_queries[522].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);
       },
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_522] = [__v_6];
-        record.function_queries[522].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);
       },
       2u64 => {
@@ -45946,77 +46046,77 @@ fn aiur_fn_522(
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_522] = [__v_7];
-            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_522] = [__v_7];
-            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_522] = { let __args: [G; IN_522] = [__v_3, __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_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_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_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_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; 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 __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_522] = [__v_8];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_522] = { let __args: [G; IN_522] = [__v_3, __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_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_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_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_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; 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 __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_522] = [__v_8];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_522] = { let __args: [G; IN_522] = [__v_3, __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_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_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_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_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; 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 __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_522] = [__v_8];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_522] = { let __args: [G; IN_522] = [__v_3, __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_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_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_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_522] = { let __args: [G; IN_522] = [__v_5, __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_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_9] = { let __args: [G; IN_9] = [__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 __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_9] = { let __args: [G; IN_9] = [__v_6, __v_9]; 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 __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_522] = [__v_10];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_522] = [__v_6];
-        record.function_queries[522].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);
       },
       8u64 => {
-        let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_5, __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_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_522] = [__v_6];
-        record.function_queries[522].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);
       },
       _ => {
@@ -46026,44 +46126,44 @@ fn aiur_fn_522(
   })
 }
 
-const INPUT_SIZE_523: usize = 4;
-const IN_523: usize = 4;
-const OUT_523: usize = 1;
-fn aiur_fn_523(
-  inp: [G; IN_523],
+const INPUT_SIZE_527: usize = 4;
+const IN_527: usize = 4;
+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_523], ExecError> {
+) -> Result<[G; OUT_527], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; 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_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 __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_523] = [__v_5];
-        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_527] = [__v_5];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_523] = [__v_6];
-            record.function_queries[523].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);
           },
           1u64 => {
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_6]; 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_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 __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __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_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 __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];
@@ -46082,18 +46182,18 @@ fn aiur_fn_523(
                 match __v_15.as_canonical_u64() {
                   0u64 => {
                     let __v_20: G = G::from_u64(1);
-                    let __ret: [G; OUT_523] = [__v_20];
-                    record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_527] = [__v_20];
+                    record.function_queries[527].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_524] = { let __args: [G; IN_524] = [__v_11, __v_14, __v_15, __v_22, __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_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 __v_23: G = __r_arr[0];
-                    let __ret: [G; OUT_523] = [__v_23];
-                    record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_527] = [__v_23];
+                    record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -46105,8 +46205,8 @@ fn aiur_fn_523(
           },
           _ => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_523] = [__v_6];
-            record.function_queries[523].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);
           },
         }
@@ -46118,15 +46218,15 @@ fn aiur_fn_523(
   })
 }
 
-const INPUT_SIZE_524: usize = 6;
-const IN_524: usize = 6;
-const OUT_524: usize = 1;
-fn aiur_fn_524(
-  inp: [G; IN_524],
+const INPUT_SIZE_528: usize = 6;
+const IN_528: usize = 6;
+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_524], 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];
@@ -46140,10 +46240,10 @@ fn aiur_fn_524(
         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_525] = { let __args: [G; IN_525] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_524] = [__v_10];
-        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_528] = [__v_10];
+        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46158,16 +46258,16 @@ fn aiur_fn_524(
             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_524] = { let __args: [G; IN_524] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; 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_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 __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_524] = [__v_14];
-            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_528] = [__v_14];
+            record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_524] = [__v_10];
-            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_528] = [__v_10];
+            record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46176,15 +46276,15 @@ fn aiur_fn_524(
   })
 }
 
-const INPUT_SIZE_525: usize = 7;
-const IN_525: usize = 7;
-const OUT_525: usize = 1;
-fn aiur_fn_525(
-  inp: [G; IN_525],
+const INPUT_SIZE_529: usize = 7;
+const IN_529: usize = 7;
+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_525], 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];
@@ -46196,13 +46296,13 @@ fn aiur_fn_525(
     let __v_7: G = (__v_1 - __v_2);
     match __v_7.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_525] = [__v_10];
-        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_529] = [__v_10];
+        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46213,13 +46313,13 @@ fn aiur_fn_525(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_9, __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 __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 __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_225] = { let __args: [G; IN_225] = [__v_12, __v_16]; 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_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 __v_17: G = __r_arr[0];
             let __v_18: G = (__v_13 - __v_17);
             let __v_19: G = G::from_u64(1);
@@ -46241,16 +46341,16 @@ fn aiur_fn_525(
             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_525] = { let __args: [G; IN_525] = [__v_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+            let __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 __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_525] = [__v_27];
-            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_529] = [__v_27];
+            record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __ret: [G; OUT_525] = [__v_12];
-            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_529] = [__v_12];
+            record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46259,15 +46359,15 @@ 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],
+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_526], 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];
@@ -46278,25 +46378,25 @@ fn aiur_fn_526(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_526] = [__v_5];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_530] = [__v_5];
+        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_3]; 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_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 __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_526] = [__v_6];
-            record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_530] = [__v_6];
+            record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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 __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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_526] = [__v_6];
-            record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_530] = [__v_6];
+            record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46311,15 +46411,15 @@ fn aiur_fn_526(
   })
 }
 
-const INPUT_SIZE_527: usize = 2;
-const IN_527: usize = 2;
-const OUT_527: usize = 1;
-fn aiur_fn_527(
-  inp: [G; IN_527],
+const INPUT_SIZE_531: usize = 2;
+const IN_531: usize = 2;
+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_527], 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];
@@ -46330,8 +46430,8 @@ fn aiur_fn_527(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_527] = [__v_5];
-        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_531] = [__v_5];
+        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -46346,24 +46446,24 @@ fn aiur_fn_527(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_527] = [__v_10];
-                record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_531] = [__v_10];
+                record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_527] = [__v_10];
-                record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_531] = [__v_10];
+                record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_527] = [__v_9];
-            record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_531] = [__v_9];
+            record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46375,15 +46475,15 @@ fn aiur_fn_527(
   })
 }
 
-const INPUT_SIZE_528: usize = 11;
-const IN_528: usize = 11;
-const OUT_528: usize = 1;
-fn aiur_fn_528(
-  inp: [G; IN_528],
+const INPUT_SIZE_532: usize = 11;
+const IN_532: usize = 11;
+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_528], 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];
@@ -46396,20 +46496,20 @@ fn aiur_fn_528(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_1, __v_4]; 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_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 __v_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_11, __v_2, __v_6, __v_7, __v_8, __v_12]; 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_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 __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_13, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } };
+    let __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 __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_529] = { let __args: [G; IN_529] = [__v_17, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+    let __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 __v_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(0);
-    let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_18, __v_3, __v_19]; 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_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 __v_20: G = __r_arr[0];
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(0);
@@ -46417,23 +46517,23 @@ fn aiur_fn_528(
     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_541] = { let __args: [G; IN_541] = [__v_26, __v_14]; 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_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 __v_27: G = __r_arr[0];
-    let __ret: [G; OUT_528] = [__v_27];
-    record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_532] = [__v_27];
+    record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_529: usize = 5;
-const IN_529: usize = 5;
-const OUT_529: usize = 1;
-fn aiur_fn_529(
-  inp: [G; IN_529],
+const INPUT_SIZE_533: usize = 5;
+const IN_533: usize = 5;
+const OUT_533: usize = 1;
+fn aiur_fn_533(
+  inp: [G; IN_533],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_529], 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];
@@ -46443,32 +46543,32 @@ fn aiur_fn_529(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_1, __v_2, __v_5]; 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_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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_529] = [__v_6];
-        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_533] = [__v_6];
+        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_4, __v_2]; 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_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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_529] = [__v_5];
-        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_533] = [__v_5];
+        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_530: usize = 3;
-const IN_530: usize = 3;
-const OUT_530: usize = 1;
-fn aiur_fn_530(
-  inp: [G; IN_530],
+const INPUT_SIZE_534: usize = 3;
+const IN_534: usize = 3;
+const OUT_534: usize = 1;
+fn aiur_fn_534(
+  inp: [G; IN_534],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_530], 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];
@@ -46479,21 +46579,21 @@ fn aiur_fn_530(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_530] = [__v_0];
-        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_534] = [__v_0];
+        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
+        let __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 __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_530] = { let __args: [G; IN_530] = [__v_10, __v_5, __v_2]; 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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_530] = [__v_11];
-        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_534] = [__v_11];
+        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46503,15 +46603,15 @@ fn aiur_fn_530(
   })
 }
 
-const INPUT_SIZE_531: usize = 6;
-const IN_531: usize = 6;
-const OUT_531: usize = 1;
-fn aiur_fn_531(
-  inp: [G; IN_531],
+const INPUT_SIZE_535: usize = 6;
+const IN_535: usize = 6;
+const OUT_535: usize = 1;
+fn aiur_fn_535(
+  inp: [G; IN_535],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_531], 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];
@@ -46521,8 +46621,8 @@ fn aiur_fn_531(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_531] = [__v_0];
-        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_535] = [__v_0];
+        record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46533,19 +46633,19 @@ fn aiur_fn_531(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_5, __v_2, __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 __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 __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_8, __v_10, __v_11]; 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_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 __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_531] = { let __args: [G; IN_531] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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_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 __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_531] = [__v_17];
-            record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_535] = [__v_17];
+            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46557,15 +46657,15 @@ fn aiur_fn_531(
   })
 }
 
-const INPUT_SIZE_532: usize = 4;
-const IN_532: usize = 4;
-const OUT_532: usize = 1;
-fn aiur_fn_532(
-  inp: [G; IN_532],
+const INPUT_SIZE_536: usize = 4;
+const IN_536: usize = 4;
+const OUT_536: usize = 1;
+fn aiur_fn_536(
+  inp: [G; IN_536],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_532], 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];
@@ -46579,20 +46679,20 @@ fn aiur_fn_532(
         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_532] = [__v_9];
-        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_536] = [__v_9];
+        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_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 __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_777] = { let __args: [G; IN_777] = [__v_3, __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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_532] = [__v_6];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_536] = [__v_6];
+            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46602,8 +46702,8 @@ fn aiur_fn_532(
             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_532] = [__v_11];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_536] = [__v_11];
+            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46612,15 +46712,15 @@ fn aiur_fn_532(
   })
 }
 
-const INPUT_SIZE_533: usize = 4;
-const IN_533: usize = 4;
-const OUT_533: usize = 1;
-fn aiur_fn_533(
-  inp: [G; IN_533],
+const INPUT_SIZE_537: usize = 4;
+const IN_537: usize = 4;
+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_533], 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];
@@ -46628,10 +46728,10 @@ fn aiur_fn_533(
     let __v_3: G = inp[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_0, __v_1]; 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_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 __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_533] = [__v_4];
-        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_537] = [__v_4];
+        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46639,29 +46739,29 @@ fn aiur_fn_533(
         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_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_4, __v_5, __v_6, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+        let __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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_533] = [__v_8];
-        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_537] = [__v_8];
+        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_534: usize = 2;
-const IN_534: usize = 2;
-const OUT_534: usize = 1;
-fn aiur_fn_534(
-  inp: [G; IN_534],
+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_534], ExecError> {
+) -> Result<[G; OUT_538], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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];
@@ -46677,29 +46777,29 @@ fn aiur_fn_534(
     let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
       6u64 => {
-        let __ret: [G; OUT_534] = [__v_8];
-        record.function_queries[534].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);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_534] = [__v_14];
-        record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_538] = [__v_14];
+        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_535: usize = 7;
-const IN_535: usize = 7;
-const OUT_535: usize = 1;
-fn aiur_fn_535(
-  inp: [G; IN_535],
+const INPUT_SIZE_539: usize = 7;
+const IN_539: usize = 7;
+const OUT_539: usize = 1;
+fn aiur_fn_539(
+  inp: [G; IN_539],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_535], 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];
@@ -46710,8 +46810,8 @@ fn aiur_fn_535(
     let __v_6: G = inp[6];
     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_539] = [__v_0];
+        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46722,19 +46822,19 @@ fn aiur_fn_535(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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_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 __v_11: G = __r_arr[0];
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_9, __v_11, __v_12]; 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_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 __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_535] = { let __args: [G; IN_535] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __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 __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 __v_18: G = __r_arr[0];
-            let __ret: [G; OUT_535] = [__v_18];
-            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_539] = [__v_18];
+            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46746,15 +46846,15 @@ fn aiur_fn_535(
   })
 }
 
-const INPUT_SIZE_536: usize = 5;
-const IN_536: usize = 5;
-const OUT_536: usize = 1;
-fn aiur_fn_536(
-  inp: [G; IN_536],
+const INPUT_SIZE_540: usize = 5;
+const IN_540: usize = 5;
+const OUT_540: usize = 1;
+fn aiur_fn_540(
+  inp: [G; IN_540],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_536], 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];
@@ -46769,23 +46869,23 @@ fn aiur_fn_536(
         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_536] = [__v_10];
-        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_540] = [__v_10];
+        record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_777] = { let __args: [G; IN_777] = [__v_4, __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_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 __v_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_2, __v_8]; 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_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 __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_536] = [__v_9];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_540] = [__v_9];
+            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46795,8 +46895,8 @@ fn aiur_fn_536(
             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_536] = [__v_12];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_540] = [__v_12];
+            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -46805,15 +46905,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_541: usize = 4;
+const IN_541: usize = 4;
+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_537], 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];
@@ -46824,15 +46924,15 @@ fn aiur_fn_537(
         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_537] = [__v_6];
-        record.function_queries[537].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);
       },
       _ => {
         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_424] = { let __args: [G; IN_424] = [__v_0, __v_6, __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_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 __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];
@@ -46844,11 +46944,11 @@ fn aiur_fn_537(
             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_537] = { let __args: [G; IN_537] = [__v_10, __v_14, __v_2, __v_3]; 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_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 __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_537] = [__v_16];
-            record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_541] = [__v_16];
+            record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -46860,15 +46960,15 @@ fn aiur_fn_537(
   })
 }
 
-const INPUT_SIZE_538: usize = 3;
-const IN_538: usize = 3;
-const OUT_538: usize = 1;
-fn aiur_fn_538(
-  inp: [G; IN_538],
+const INPUT_SIZE_542: usize = 3;
+const IN_542: usize = 3;
+const OUT_542: usize = 1;
+fn aiur_fn_542(
+  inp: [G; IN_542],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_538], ExecError> {
+) -> Result<[G; OUT_542], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46879,8 +46979,8 @@ fn aiur_fn_538(
         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_538] = [__v_6];
-        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_542] = [__v_6];
+        record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46891,26 +46991,26 @@ fn aiur_fn_538(
         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_538] = { let __args: [G; IN_538] = [__v_0, __v_1, __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 __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 __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_538] = [__v_12];
-        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_542] = [__v_12];
+        record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_539: usize = 4;
-const IN_539: usize = 4;
-const OUT_539: usize = 1;
-fn aiur_fn_539(
-  inp: [G; IN_539],
+const INPUT_SIZE_543: usize = 4;
+const IN_543: usize = 4;
+const OUT_543: usize = 1;
+fn aiur_fn_543(
+  inp: [G; IN_543],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_539], 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];
@@ -46919,8 +47019,8 @@ fn aiur_fn_539(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.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_543] = [__v_0];
+        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46936,25 +47036,25 @@ fn aiur_fn_539(
         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_539] = { let __args: [G; IN_539] = [__v_14, __v_1, __v_2, __v_16]; 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_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 __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_539] = [__v_17];
-        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_543] = [__v_17];
+        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_540: usize = 3;
-const IN_540: usize = 3;
-const OUT_540: usize = 1;
-fn aiur_fn_540(
-  inp: [G; IN_540],
+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_540], 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];
@@ -46962,8 +47062,8 @@ fn aiur_fn_540(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_540] = [__v_0];
-        record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_544] = [__v_0];
+        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -46978,25 +47078,25 @@ fn aiur_fn_540(
         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_540] = { let __args: [G; IN_540] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
+        let __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 __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_540] = [__v_15];
-        record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_544] = [__v_15];
+        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_541: usize = 2;
-const IN_541: usize = 2;
-const OUT_541: usize = 1;
-fn aiur_fn_541(
-  inp: [G; IN_541],
+const INPUT_SIZE_545: usize = 2;
+const IN_545: usize = 2;
+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_541], 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];
@@ -47006,18 +47106,18 @@ fn aiur_fn_541(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_541] = [__v_0];
-        record.function_queries[541].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);
       },
       0u64 => {
         let __v_5: G = G::from_u64(5);
-        let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __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 __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 __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_541] = [__v_8];
-        record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_545] = [__v_8];
+        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -47027,15 +47127,15 @@ fn aiur_fn_541(
   })
 }
 
-const INPUT_SIZE_542: usize = 16;
-const IN_542: usize = 16;
-const OUT_542: usize = 1;
-fn aiur_fn_542(
-  inp: [G; IN_542],
+const INPUT_SIZE_546: usize = 16;
+const IN_546: usize = 16;
+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_542], 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];
@@ -47053,15 +47153,15 @@ fn aiur_fn_542(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2, __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_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 __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_534] = { let __args: [G; IN_534] = [__v_1, __v_14]; 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_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 __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_535] = { let __args: [G; IN_535] = [__v_16, __v_19, __v_18, __v_20, __v_3, __v_4, __v_21]; 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_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 __v_22: G = __r_arr[0];
     let __v_23: G = G::from_u64(1);
     let __v_24: G = G::from_u64(1);
@@ -47076,24 +47176,24 @@ fn aiur_fn_542(
     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_545] = { let __args: [G; IN_545] = [__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[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_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 __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_196] = { let __args: [G; IN_196] = [__v_36]; 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_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 __v_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_37]; 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_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 __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_198] = { let __args: [G; IN_198] = [__v_39]; 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_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 __v_44: G = __r_arr[0];
     let __v_45: G = __r_arr[1];
-    let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_45, __v_19]; 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_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 __v_46: G = __r_arr[0];
     let __v_47: G = G::from_u64(0);
-    let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_46, __v_41, __v_47]; 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_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 __v_48: G = __r_arr[0];
     let __v_49: G = G::from_u64(1);
     let __v_50: G = (__v_43 - __v_49);
@@ -47102,15 +47202,15 @@ fn aiur_fn_542(
     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_410] = { let __args: [G; IN_410] = [__v_55, __v_48]; 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_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 __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_543] = { let __args: [G; IN_543] = [__v_59, __v_19, __v_9, __v_43, __v_3, __v_4]; 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_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 __v_60: G = __r_arr[0];
     let __v_61: G = G::from_u64(0);
-    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_60, __v_40, __v_42, __v_61]; 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_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 __v_62: G = __r_arr[0];
     let __v_63: G = G::from_u64(3);
     let __v_64: G = G::from_u64(0);
@@ -47119,27 +47219,27 @@ fn aiur_fn_542(
     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_636] = { let __args: [G; IN_636] = [__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[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_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 __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_65, __v_70]; 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_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 __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_71, __v_36]; 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_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 __v_72: G = __r_arr[0];
-    let __ret: [G; OUT_542] = [__v_72];
-    record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_546] = [__v_72];
+    record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_543: usize = 6;
-const IN_543: usize = 6;
-const OUT_543: usize = 1;
-fn aiur_fn_543(
-  inp: [G; IN_543],
+const INPUT_SIZE_547: usize = 6;
+const IN_547: usize = 6;
+const OUT_547: usize = 1;
+fn aiur_fn_547(
+  inp: [G; IN_547],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_543], 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];
@@ -47152,33 +47252,33 @@ fn aiur_fn_543(
         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_559] = { let __args: [G; IN_559] = [__v_0, __v_2, __v_7, __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 __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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_543] = [__v_9];
-        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_547] = [__v_9];
+        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = (__v_3 - __v_2);
-        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_5, __v_6]; 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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_543] = [__v_7];
-        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_547] = [__v_7];
+        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_544: usize = 4;
-const IN_544: usize = 4;
-const OUT_544: usize = 1;
-fn aiur_fn_544(
-  inp: [G; IN_544],
+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_544], 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];
@@ -47186,8 +47286,8 @@ fn aiur_fn_544(
     let __v_3: G = inp[3];
     match __v_1.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_548] = [__v_0];
+        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -47205,16 +47305,16 @@ fn aiur_fn_544(
             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_402] = { let __args: [G; IN_402] = [__v_6, __v_13, __v_14]; 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_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_544] = { let __args: [G; IN_544] = [__v_15, __v_17, __v_2, __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_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_544] = [__v_20];
-            record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_548] = [__v_20];
+            record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47226,15 +47326,15 @@ fn aiur_fn_544(
   })
 }
 
-const INPUT_SIZE_545: usize = 10;
-const IN_545: usize = 10;
-const OUT_545: usize = 4;
-fn aiur_fn_545(
-  inp: [G; IN_545],
+const INPUT_SIZE_549: usize = 10;
+const IN_549: usize = 10;
+const OUT_549: usize = 4;
+fn aiur_fn_549(
+  inp: [G; IN_549],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_545], 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];
@@ -47253,7 +47353,7 @@ fn aiur_fn_545(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_11, __v_1, __v_5, __v_6, __v_7, __v_9]; 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_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 __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = G::from_u64(0);
@@ -47268,57 +47368,57 @@ fn aiur_fn_545(
             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_545] = { let __args: [G; IN_545] = [__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[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_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 __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_545] = [__v_26, __v_27, __v_28, __v_29];
-            record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_549] = [__v_26, __v_27, __v_28, __v_29];
+            record.function_queries[549].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_545] = { let __args: [G; IN_545] = [__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[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_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 __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_545] = [__v_22, __v_23, __v_24, __v_25];
-            record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_549] = [__v_22, __v_23, __v_24, __v_25];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; 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_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 __v_14: G = __r_arr[0];
-        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_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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; 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_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 __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_545] = [__v_14, __v_15, __v_16, __v_0];
-        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_549] = [__v_14, __v_15, __v_16, __v_0];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_546: usize = 2;
-const IN_546: usize = 2;
-const OUT_546: usize = 1;
-fn aiur_fn_546(
-  inp: [G; IN_546],
+const INPUT_SIZE_550: usize = 2;
+const IN_550: usize = 2;
+const OUT_550: usize = 1;
+fn aiur_fn_550(
+  inp: [G; IN_550],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_546], ExecError> {
+) -> Result<[G; OUT_550], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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];
@@ -47367,7 +47467,7 @@ fn aiur_fn_546(
         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_126] = { let __args: [G; IN_126] = [__v_10, __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 __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 __v_47: G = __r_arr[0];
         match __v_47.as_canonical_u64() {
           1u64 => {
@@ -47376,30 +47476,30 @@ fn aiur_fn_546(
             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_546] = [__v_52];
-            record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_550] = [__v_52];
+            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_48: G = G::from_u64(0);
-            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_1, __v_48]; 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_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 __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_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 __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 __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_773] = { let __args: [G; IN_773] = [__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[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_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 __v_59: G = __r_arr[0];
-            let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_59, __v_10]; 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_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 __v_60: G = __r_arr[0];
-            let __ret: [G; OUT_546] = [__v_60];
-            record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_550] = [__v_60];
+            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47413,23 +47513,23 @@ fn aiur_fn_546(
         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_546] = [__v_18];
-        record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_550] = [__v_18];
+        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_547: usize = 2;
-const IN_547: usize = 2;
-const OUT_547: usize = 6;
-fn aiur_fn_547(
-  inp: [G; IN_547],
+const INPUT_SIZE_551: usize = 2;
+const IN_551: usize = 2;
+const OUT_551: usize = 6;
+fn aiur_fn_551(
+  inp: [G; IN_551],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_547], 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];
@@ -47441,8 +47541,8 @@ fn aiur_fn_547(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_547] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -47460,7 +47560,7 @@ fn aiur_fn_547(
         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_547] = { let __args: [G; IN_547] = [__v_4, __v_17]; 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_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 __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -47502,24 +47602,24 @@ fn aiur_fn_547(
             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_126] = { let __args: [G; IN_126] = [__v_12, __v_56]; 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_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 __v_57: G = __r_arr[0];
             match __v_57.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_547] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-                record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__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[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 __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 __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_547] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-                record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -47528,8 +47628,8 @@ fn aiur_fn_547(
             }
           },
           _ => {
-            let __ret: [G; OUT_547] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-            record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -47541,15 +47641,15 @@ fn aiur_fn_547(
   })
 }
 
-const INPUT_SIZE_548: usize = 8;
-const IN_548: usize = 8;
-const OUT_548: usize = 6;
-fn aiur_fn_548(
-  inp: [G; IN_548],
+const INPUT_SIZE_552: usize = 8;
+const IN_552: usize = 8;
+const OUT_552: usize = 6;
+fn aiur_fn_552(
+  inp: [G; IN_552],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_548], 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];
@@ -47559,37 +47659,37 @@ fn aiur_fn_548(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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_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 __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_773] = { let __args: [G; IN_773] = [__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[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_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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+    let __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 __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__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[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_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 __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_548] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-    record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_549: usize = 3;
-const IN_549: usize = 3;
-const OUT_549: usize = 1;
-fn aiur_fn_549(
-  inp: [G; IN_549],
+const INPUT_SIZE_553: usize = 3;
+const IN_553: usize = 3;
+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_549], 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];
@@ -47611,12 +47711,12 @@ fn aiur_fn_549(
         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_549] = [__v_16];
-        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_553] = [__v_16];
+        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_1]; 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_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 __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
@@ -47624,17 +47724,17 @@ fn aiur_fn_549(
             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_549] = [__v_11];
-            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_553] = [__v_11];
+            record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6, __v_1, __v_2]; 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_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 __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_549] = [__v_10];
-            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_553] = [__v_10];
+            record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47649,15 +47749,15 @@ fn aiur_fn_549(
   })
 }
 
-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_554: usize = 2;
+const IN_554: usize = 2;
+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_550], 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];
@@ -47671,24 +47771,24 @@ fn aiur_fn_550(
         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_550] = [__v_8];
-        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_554] = [__v_8];
+        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_1]; 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_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 __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_550] = [__v_4];
-            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_554] = [__v_4];
+            record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_5, __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_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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_550] = [__v_7];
-            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_554] = [__v_7];
+            record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -47703,20 +47803,20 @@ fn aiur_fn_550(
   })
 }
 
-const INPUT_SIZE_551: usize = 3;
-const IN_551: usize = 3;
-const OUT_551: usize = 1;
-fn aiur_fn_551(
-  inp: [G; IN_551],
+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_551], ExecError> {
+) -> Result<[G; OUT_555], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_1]; 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_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];
@@ -47765,17 +47865,17 @@ fn aiur_fn_551(
         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_126] = { let __args: [G; IN_126] = [__v_11, __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 __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_551] = [__v_49];
-            record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_777] = { let __args: [G; IN_777] = [__v_2, __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_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];
@@ -47791,16 +47891,16 @@ fn aiur_fn_551(
             let __v_60: G = __loaded[10];
             match __v_50.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_57, __v_11]; 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_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_551] = [__v_61];
-                record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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_551] = [__v_61];
-                record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_555] = [__v_61];
+                record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -47812,23 +47912,23 @@ fn aiur_fn_551(
       },
       _ => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_551] = [__v_15];
-        record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_555] = [__v_15];
+        record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_552: usize = 6;
-const IN_552: usize = 6;
-const OUT_552: usize = 2;
-fn aiur_fn_552(
-  inp: [G; IN_552],
+const INPUT_SIZE_556: usize = 6;
+const IN_556: usize = 6;
+const OUT_556: usize = 2;
+fn aiur_fn_556(
+  inp: [G; IN_556],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_552], 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];
@@ -47836,16 +47936,16 @@ fn aiur_fn_552(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0]; 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_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 __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; 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_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 __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_8, __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 __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 __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_9, __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_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 __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10]; 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_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 __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 };
@@ -47855,37 +47955,37 @@ fn aiur_fn_552(
     let __v_16: G = __loaded[3];
     match __v_13.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_553] = { let __args: [G; IN_553] = [__v_1, __v_14, __v_12, __v_19, __v_18]; 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_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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
-        let __ret: [G; OUT_552] = [__v_20, __v_21];
-        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_556] = [__v_20, __v_21];
+        record.function_queries[556].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_552] = [__v_17, __v_18];
-        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_556] = [__v_17, __v_18];
+        record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_553: usize = 5;
-const IN_553: usize = 5;
-const OUT_553: usize = 2;
-fn aiur_fn_553(
-  inp: [G; IN_553],
+const INPUT_SIZE_557: usize = 5;
+const IN_557: usize = 5;
+const OUT_557: usize = 2;
+fn aiur_fn_557(
+  inp: [G; IN_557],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_553], 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];
@@ -47903,31 +48003,31 @@ fn aiur_fn_553(
       1u64 => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_553] = [__v_11, __v_12];
-        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_557] = [__v_11, __v_12];
+        record.function_queries[557].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_554] = { let __args: [G; IN_554] = [__v_2, __v_8, __v_4]; 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_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 __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_553] = [__v_13, __v_3];
-                record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_557] = [__v_13, __v_3];
+                record.function_queries[557].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_553] = { let __args: [G; IN_553] = [__v_10, __v_1, __v_2, __v_14, __v_4]; 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_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 __v_15: G = __r_arr[0];
                 let __v_16: G = __r_arr[1];
-                let __ret: [G; OUT_553] = [__v_15, __v_16];
-                record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_557] = [__v_15, __v_16];
+                record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -47935,11 +48035,11 @@ fn aiur_fn_553(
           _ => {
             let __v_12: G = G::from_u64(1);
             let __v_13: G = (__v_3 + __v_12);
-            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_10, __v_1, __v_2, __v_13, __v_4]; 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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_553] = [__v_14, __v_15];
-            record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_557] = [__v_14, __v_15];
+            record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -47951,15 +48051,15 @@ fn aiur_fn_553(
   })
 }
 
-const INPUT_SIZE_554: usize = 3;
-const IN_554: usize = 3;
-const OUT_554: usize = 1;
-fn aiur_fn_554(
-  inp: [G; IN_554],
+const INPUT_SIZE_558: usize = 3;
+const IN_558: usize = 3;
+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_554], 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];
@@ -47971,8 +48071,8 @@ fn aiur_fn_554(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_554] = [__v_6];
-        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_558] = [__v_6];
+        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -47983,28 +48083,28 @@ fn aiur_fn_554(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_554] = [__v_9];
-            record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_558] = [__v_9];
+            record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __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 __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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_10]; 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_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 __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_8, __v_5, __v_2]; 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_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 __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_554] = [__v_12];
-                record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_558] = [__v_12];
+                record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_554] = [__v_12];
-                record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_558] = [__v_12];
+                record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -48021,15 +48121,15 @@ fn aiur_fn_554(
   })
 }
 
-const INPUT_SIZE_555: usize = 3;
-const IN_555: usize = 3;
-const OUT_555: usize = 2;
-fn aiur_fn_555(
-  inp: [G; IN_555],
+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_555], 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];
@@ -48042,8 +48142,8 @@ fn aiur_fn_555(
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_555] = [__v_6, __v_7];
-        record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_559] = [__v_6, __v_7];
+        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -48051,18 +48151,18 @@ fn aiur_fn_555(
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_555] = [__v_7, __v_2];
-            record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_555] = { let __args: [G; IN_555] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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_555] = [__v_9, __v_10];
-            record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_559] = [__v_9, __v_10];
+            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48074,40 +48174,40 @@ fn aiur_fn_555(
   })
 }
 
-const INPUT_SIZE_556: usize = 1;
-const IN_556: usize = 1;
-const OUT_556: usize = 2;
-fn aiur_fn_556(
-  inp: [G; IN_556],
+const INPUT_SIZE_560: usize = 1;
+const IN_560: usize = 1;
+const OUT_560: usize = 2;
+fn aiur_fn_560(
+  inp: [G; IN_560],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_556], ExecError> {
+) -> Result<[G; OUT_560], 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_557] = { let __args: [G; IN_557] = [__v_0, __v_3]; 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_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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; 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_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 __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_556] = [__v_6, __v_5];
-    record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_560] = [__v_6, __v_5];
+    record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_557: usize = 2;
-const IN_557: usize = 2;
-const OUT_557: usize = 2;
-fn aiur_fn_557(
-  inp: [G; IN_557],
+const INPUT_SIZE_561: usize = 2;
+const IN_561: usize = 2;
+const OUT_561: usize = 2;
+fn aiur_fn_561(
+  inp: [G; IN_561],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_557], 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];
@@ -48120,31 +48220,31 @@ fn aiur_fn_557(
       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_557] = { let __args: [G; IN_557] = [__v_4, __v_7]; 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_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 __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_557] = [__v_8, __v_9];
-        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_561] = [__v_8, __v_9];
+        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_557] = [__v_1, __v_0];
-        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_561] = [__v_1, __v_0];
+        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_562: usize = 3;
+const IN_562: usize = 3;
+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_558], 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];
@@ -48158,19 +48258,19 @@ fn aiur_fn_558(
         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_558] = [__v_8];
-        record.function_queries[558].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);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        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 __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_5, __v_1, __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_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 __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_558] = [__v_9];
-        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_562] = [__v_9];
+        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48180,15 +48280,15 @@ fn aiur_fn_558(
   })
 }
 
-const INPUT_SIZE_559: usize = 4;
-const IN_559: usize = 4;
-const OUT_559: usize = 1;
-fn aiur_fn_559(
-  inp: [G; IN_559],
+const INPUT_SIZE_563: usize = 4;
+const IN_563: usize = 4;
+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_559], 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];
@@ -48197,8 +48297,8 @@ fn aiur_fn_559(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_559] = [__v_0];
-        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_563] = [__v_0];
+        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48211,25 +48311,25 @@ fn aiur_fn_559(
         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_559] = { let __args: [G; IN_559] = [__v_11, __v_1, __v_2, __v_13]; 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 __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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_559] = [__v_14];
-        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_563] = [__v_14];
+        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_560: usize = 4;
-const IN_560: usize = 4;
-const OUT_560: usize = 1;
-fn aiur_fn_560(
-  inp: [G; IN_560],
+const INPUT_SIZE_564: usize = 4;
+const IN_564: usize = 4;
+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_560], 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];
@@ -48238,8 +48338,8 @@ fn aiur_fn_560(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_560] = [__v_0];
-        record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_564] = [__v_0];
+        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48254,59 +48354,59 @@ fn aiur_fn_560(
         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_560] = { let __args: [G; IN_560] = [__v_13, __v_1, __v_2, __v_15]; 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_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 __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_560] = [__v_16];
-        record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_564] = [__v_16];
+        record.function_queries[564].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_565: usize = 2;
+const IN_565: usize = 2;
+const OUT_565: usize = 2;
+fn aiur_fn_565(
+  inp: [G; IN_565],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_561], ExecError> {
+) -> Result<[G; OUT_565], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = 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_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_4]; 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_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 __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; 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_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 __v_7: G = __r_arr[0];
-    let __ret: [G; OUT_561] = [__v_7, __v_6];
-    record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_565] = [__v_7, __v_6];
+    record.function_queries[565].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 = 2;
-fn aiur_fn_562(
-  inp: [G; IN_562],
+const INPUT_SIZE_566: usize = 3;
+const IN_566: usize = 3;
+const OUT_566: usize = 2;
+fn aiur_fn_566(
+  inp: [G; IN_566],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_562], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_562] = [__v_2, __v_0];
-        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_566] = [__v_2, __v_0];
+        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48321,11 +48421,11 @@ fn aiur_fn_562(
             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_562] = { let __args: [G; IN_562] = [__v_5, __v_8, __v_10]; 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_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 __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_562] = [__v_11, __v_12];
-            record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_566] = [__v_11, __v_12];
+            record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -48337,15 +48437,15 @@ fn aiur_fn_562(
   })
 }
 
-const INPUT_SIZE_563: usize = 3;
-const IN_563: usize = 3;
-const OUT_563: usize = 1;
-fn aiur_fn_563(
-  inp: [G; IN_563],
+const INPUT_SIZE_567: usize = 3;
+const IN_567: usize = 3;
+const OUT_567: usize = 1;
+fn aiur_fn_567(
+  inp: [G; IN_567],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_563], 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];
@@ -48353,8 +48453,8 @@ fn aiur_fn_563(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.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_567] = [__v_0];
+        record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48367,25 +48467,25 @@ fn aiur_fn_563(
         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_563] = { let __args: [G; IN_563] = [__v_10, __v_1, __v_12]; 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_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 __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_563] = [__v_13];
-        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_567] = [__v_13];
+        record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_564: usize = 15;
-const IN_564: usize = 15;
-const OUT_564: usize = 1;
-fn aiur_fn_564(
-  inp: [G; IN_564],
+const INPUT_SIZE_568: usize = 15;
+const IN_568: usize = 15;
+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_564], 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];
@@ -48411,12 +48511,12 @@ fn aiur_fn_564(
         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_564] = [__v_20];
-        record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_568] = [__v_20];
+        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_12, __v_16]; 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_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 __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];
@@ -48432,16 +48532,16 @@ fn aiur_fn_564(
         let __v_29: G = __loaded[10];
         match __v_19.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__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[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_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 __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_564] = { let __args: [G; IN_564] = [__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[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_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 __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_564] = [__v_35];
-            record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_568] = [__v_35];
+            record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -48456,15 +48556,15 @@ fn aiur_fn_564(
   })
 }
 
-const INPUT_SIZE_565: usize = 8;
-const IN_565: usize = 8;
-const OUT_565: usize = 1;
-fn aiur_fn_565(
-  inp: [G; IN_565],
+const INPUT_SIZE_569: usize = 8;
+const IN_569: usize = 8;
+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_565], 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];
@@ -48475,23 +48575,23 @@ fn aiur_fn_565(
     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_566] = { let __args: [G; IN_566] = [__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[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_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 __v_9: G = __r_arr[0];
-    let __ret: [G; OUT_565] = [__v_9];
-    record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_569] = [__v_9];
+    record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_566: usize = 9;
-const IN_566: usize = 9;
-const OUT_566: usize = 1;
-fn aiur_fn_566(
-  inp: [G; IN_566],
+const INPUT_SIZE_570: usize = 9;
+const IN_570: usize = 9;
+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_566], 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];
@@ -48514,12 +48614,12 @@ fn aiur_fn_566(
         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_566] = [__v_17];
-        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_570] = [__v_17];
+        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__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_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 __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];
@@ -48535,26 +48635,26 @@ fn aiur_fn_566(
         let __v_26: G = __loaded[10];
         match __v_16.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__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[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_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 __v_27: G = __r_arr[0];
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_27, __v_8, __v_28]; 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_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 __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_566] = { let __args: [G; IN_566] = [__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[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_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 __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_566] = [__v_34];
-            record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_570] = [__v_34];
+            record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__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[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_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 __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_566] = [__v_27];
-            record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_570] = [__v_27];
+            record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48566,15 +48666,15 @@ fn aiur_fn_566(
   })
 }
 
-const INPUT_SIZE_567: usize = 11;
-const IN_567: usize = 11;
-const OUT_567: usize = 1;
-fn aiur_fn_567(
-  inp: [G; IN_567],
+const INPUT_SIZE_571: usize = 11;
+const IN_571: usize = 11;
+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_567], 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];
@@ -48588,23 +48688,23 @@ fn aiur_fn_567(
     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_568] = { let __args: [G; IN_568] = [__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[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_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 __v_12: G = __r_arr[0];
-    let __ret: [G; OUT_567] = [__v_12];
-    record.function_queries[567].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);
   })
 }
 
-const INPUT_SIZE_568: usize = 13;
-const IN_568: usize = 13;
-const OUT_568: usize = 1;
-fn aiur_fn_568(
-  inp: [G; IN_568],
+const INPUT_SIZE_572: usize = 13;
+const IN_572: usize = 13;
+const OUT_572: usize = 1;
+fn aiur_fn_572(
+  inp: [G; IN_572],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_568], 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];
@@ -48631,12 +48731,12 @@ fn aiur_fn_568(
         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_568] = [__v_21];
-        record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_572] = [__v_21];
+        record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_9, __v_14]; 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_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 __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];
@@ -48652,28 +48752,28 @@ fn aiur_fn_568(
         let __v_30: G = __loaded[10];
         match __v_20.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__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[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_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 __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_31]; 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_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 __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_568] = { let __args: [G; IN_568] = [__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[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_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 __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_31, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 __v_37: G = __r_arr[0];
-            let __ret: [G; OUT_568] = [__v_37];
-            record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_572] = [__v_37];
+            record.function_queries[572].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_568] = { let __args: [G; IN_568] = [__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[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_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 __v_33: G = __r_arr[0];
-            let __ret: [G; OUT_568] = [__v_33];
-            record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_572] = [__v_33];
+            record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -48685,15 +48785,15 @@ fn aiur_fn_568(
   })
 }
 
-const INPUT_SIZE_569: usize = 11;
-const IN_569: usize = 11;
-const OUT_569: usize = 1;
-fn aiur_fn_569(
-  inp: [G; IN_569],
+const INPUT_SIZE_573: usize = 11;
+const IN_573: usize = 11;
+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_569], 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];
@@ -48710,9 +48810,9 @@ fn aiur_fn_569(
     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_504] = { let __args: [G; IN_504] = [__v_1, __v_11, __v_14, __v_9, __v_10]; 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 __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 __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_15, __v_2, __v_9, __v_10]; 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_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 __v_16: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_16.as_canonical_u64() {
   1u64 => {
@@ -48734,40 +48834,40 @@ fn aiur_fn_569(
 }
  };
     let __v_17: G = __mc_out___mc_0[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_7, __v_9]; 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_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 __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_18, __v_16, __v_9, __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_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 __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_19]; 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_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 __v_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_19]; 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_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 __v_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_19, __v_8]; 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_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 __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_231] = { let __args: [G; IN_231] = [__v_1, __v_25]; 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_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 __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_26, __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_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 __v_27: G = __r_arr[0];
     let __v_28: G = __r_arr[1];
-    let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_19, __v_9]; 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_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 __v_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__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[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_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 __v_30: G = __r_arr[0];
     let __v_31: G = G::from_u64(0);
-    let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__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[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_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 __v_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_32]; 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_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 __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_28, __v_4, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } };
+    let __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 __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_580] = { let __args: [G; IN_580] = [__v_34, __v_35, __v_36]; 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_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 __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_19, __v_8]; 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_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 __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -48782,10 +48882,10 @@ fn aiur_fn_569(
     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_619] = { let __args: [G; IN_619] = [__v_44, __v_3, __v_49, __v_51, __v_39, __v_40]; 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_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 __v_52: G = __r_arr[0];
     let __v_53: G = G::from_u64(0);
-    let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_52, __v_4, __v_53]; 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_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 __v_54: G = __r_arr[0];
     let __v_55: G = G::from_u64(1);
     let __v_56: G = (__v_47 + __v_55);
@@ -48797,7 +48897,7 @@ fn aiur_fn_569(
     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_563] = { let __args: [G; IN_563] = [__v_63, __v_4, __v_64]; 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_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 __v_65: G = __r_arr[0];
     let __v_66: G = G::from_u64(3);
     let __v_67: G = G::from_u64(0);
@@ -48809,29 +48909,29 @@ fn aiur_fn_569(
     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_541] = { let __args: [G; IN_541] = [__v_75, __v_37]; 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_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 __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_76, __v_32]; 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_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 __v_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_77, __v_30]; 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_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 __v_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_78, __v_27]; 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_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 __v_79: G = __r_arr[0];
-    let __ret: [G; OUT_569] = [__v_79];
-    record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_573] = [__v_79];
+    record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_570: usize = 22;
-const IN_570: usize = 22;
-const OUT_570: usize = 1;
-fn aiur_fn_570(
-  inp: [G; IN_570],
+const INPUT_SIZE_574: usize = 22;
+const IN_574: usize = 22;
+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_570], 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];
@@ -48857,13 +48957,13 @@ fn aiur_fn_570(
     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_571] = { let __args: [G; IN_571] = [__v_22, __v_23]; 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_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 __v_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_19]; 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_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 __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_20]; 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_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 __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25, __v_26, __v_17, __v_18]; 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_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 __v_27: G = __r_arr[0];
     let __v_28: G = G::from_u64(1);
     let __v_29: G = G::from_u64(1);
@@ -48879,14 +48979,14 @@ fn aiur_fn_570(
     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_545] = { let __args: [G; IN_545] = [__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[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_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 __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_196] = { let __args: [G; IN_196] = [__v_42]; 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_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 __v_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_43]; 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_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 __v_47: G = __r_arr[0];
     let __v_48: G = (__v_7 + __v_46);
     let __v_49: G = (__v_6 + __v_48);
@@ -48900,41 +49000,41 @@ fn aiur_fn_570(
     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_560] = { let __args: [G; IN_560] = [__v_58, __v_46, __v_46, __v_59]; 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_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 __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_573] = { let __args: [G; IN_573] = [__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[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_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 __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_580] = { let __args: [G; IN_580] = [__v_42, __v_66, __v_67]; 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_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 __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_65, __v_68]; 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_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 __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_69, __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_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 __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_70, __v_10]; 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_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 __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_71, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
+    let __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 __v_72: G = __r_arr[0];
-    let __ret: [G; OUT_570] = [__v_72];
-    record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_574] = [__v_72];
+    record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_571: usize = 2;
-const IN_571: usize = 2;
-const OUT_571: usize = 1;
-fn aiur_fn_571(
-  inp: [G; IN_571],
+const INPUT_SIZE_575: usize = 2;
+const IN_575: usize = 2;
+const OUT_575: usize = 1;
+fn aiur_fn_575(
+  inp: [G; IN_575],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_571], 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];
@@ -48944,8 +49044,8 @@ fn aiur_fn_571(
         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_571] = [__v_5];
-        record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_575] = [__v_5];
+        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -48955,26 +49055,26 @@ fn aiur_fn_571(
         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_571] = { let __args: [G; IN_571] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
+        let __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 __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_571] = [__v_10];
-        record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_575] = [__v_10];
+        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_572: usize = 2;
-const IN_572: usize = 2;
-const OUT_572: usize = 1;
-fn aiur_fn_572(
-  inp: [G; IN_572],
+const INPUT_SIZE_576: usize = 2;
+const IN_576: usize = 2;
+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_572], 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];
@@ -48984,18 +49084,18 @@ fn aiur_fn_572(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_572] = [__v_0];
-        record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_576] = [__v_0];
+        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(4);
-        let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_4]; 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_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 __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_572] = [__v_8];
-        record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_576] = [__v_8];
+        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49005,15 +49105,15 @@ fn aiur_fn_572(
   })
 }
 
-const INPUT_SIZE_573: usize = 15;
-const IN_573: usize = 15;
-const OUT_573: usize = 1;
-fn aiur_fn_573(
-  inp: [G; IN_573],
+const INPUT_SIZE_577: usize = 15;
+const IN_577: usize = 15;
+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_573], 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];
@@ -49036,41 +49136,41 @@ fn aiur_fn_573(
     let __v_17: G = __loaded[2];
     match __v_15.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_573] = [__v_0];
-        record.function_queries[573].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_777] = { let __args: [G; IN_777] = [__v_2, __v_14]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_18]; 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_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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __v_18]; 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_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 __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_777] = { let __args: [G; IN_777] = [__v_3, __v_16]; 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_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 __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_396] = { let __args: [G; IN_396] = [__v_24, __v_25, __v_26]; 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_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 __v_27: G = __r_arr[0];
         let __v_28: G = (__v_7 + __v_8);
-        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_27, __v_28, __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 __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 __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_29, __v_11, __v_12, __v_13]; 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_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 __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_30]; 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_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 __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_31]; 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_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 __v_33: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_33, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_32, __v_34, __v_12, __v_13]; 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_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 __v_35: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_31]; 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_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 __v_36: G = __r_arr[0];
         let __v_37: G = (__v_23 + __v_36);
         let __v_38: G = G::from_u64(2);
@@ -49079,27 +49179,27 @@ fn aiur_fn_573(
         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_559] = { let __args: [G; IN_559] = [__v_40, __v_6, __v_42, __v_43]; 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 __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 __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_559] = { let __args: [G; IN_559] = [__v_44, __v_7, __v_47, __v_48]; 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 __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 __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_559] = { let __args: [G; IN_559] = [__v_49, __v_8, __v_53, __v_54]; 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 __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 __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_35]; 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_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 __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
-        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_57, __v_20]; 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_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 __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_55, __v_58]; 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_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 __v_59: G = __r_arr[0];
         let __v_60: G = G::from_u64(1);
         let __v_61: G = (__v_9 - __v_60);
@@ -49109,22 +49209,22 @@ fn aiur_fn_573(
         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_540] = { let __args: [G; IN_540] = [__v_66, __v_36, __v_67]; 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_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 __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_572] = { let __args: [G; IN_572] = [__v_71, __v_31]; 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_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 __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_573] = { let __args: [G; IN_573] = [__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[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_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 __v_78: G = __r_arr[0];
-        let __ret: [G; OUT_573] = [__v_78];
-        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_577] = [__v_78];
+        record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49134,15 +49234,15 @@ fn aiur_fn_573(
   })
 }
 
-const INPUT_SIZE_574: usize = 7;
-const IN_574: usize = 7;
-const OUT_574: usize = 1;
-fn aiur_fn_574(
-  inp: [G; IN_574],
+const INPUT_SIZE_578: usize = 7;
+const IN_578: usize = 7;
+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_574], 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];
@@ -49154,7 +49254,7 @@ fn aiur_fn_574(
     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_501] = { let __args: [G; IN_501] = [__v_1, __v_9]; 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_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 __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];
@@ -49163,7 +49263,7 @@ fn aiur_fn_574(
     let __v_14: G = __loaded[3];
     match __v_11.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__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 __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 __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 };
@@ -49173,8 +49273,8 @@ fn aiur_fn_574(
         let __v_20: G = __loaded[3];
         match __v_17.as_canonical_u64() {
           2u64 => {
-            let __ret: [G; OUT_574] = [__v_18];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_578] = [__v_18];
+            record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49189,15 +49289,15 @@ fn aiur_fn_574(
   })
 }
 
-const INPUT_SIZE_575: usize = 6;
-const IN_575: usize = 6;
-const OUT_575: usize = 1;
-fn aiur_fn_575(
-  inp: [G; IN_575],
+const INPUT_SIZE_579: usize = 6;
+const IN_579: usize = 6;
+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_575], 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];
@@ -49208,7 +49308,7 @@ fn aiur_fn_575(
     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_509] = { let __args: [G; IN_509] = [__v_0, __v_8]; 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_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 __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];
@@ -49217,40 +49317,40 @@ fn aiur_fn_575(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; 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_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 __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_15, __v_5]; 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_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 __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_632] = { let __args: [G; IN_632] = [__v_16, __v_18]; 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_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 __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_575] = [__v_19];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_579] = [__v_19];
+        record.function_queries[579].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_575] = [__v_16];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_579] = [__v_16];
+        record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_576: usize = 6;
-const IN_576: usize = 6;
-const OUT_576: usize = 1;
-fn aiur_fn_576(
-  inp: [G; IN_576],
+const INPUT_SIZE_580: usize = 6;
+const IN_580: usize = 6;
+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_576], 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];
@@ -49260,36 +49360,36 @@ fn aiur_fn_576(
     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_577] = { let __args: [G; IN_577] = [__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[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_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 __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_577] = { let __args: [G; IN_577] = [__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[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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_576] = [__v_11];
-        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_580] = [__v_11];
+        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_576] = [__v_8];
-        record.function_queries[576].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);
       },
     }
   })
 }
 
-const INPUT_SIZE_577: usize = 9;
-const IN_577: usize = 9;
-const OUT_577: usize = 1;
-fn aiur_fn_577(
-  inp: [G; IN_577],
+const INPUT_SIZE_581: usize = 9;
+const IN_581: usize = 9;
+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_577], ExecError> {
+) -> Result<[G; OUT_581], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49307,8 +49407,8 @@ fn aiur_fn_577(
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_577] = [__v_12];
-        record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_581] = [__v_12];
+        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -49326,7 +49426,7 @@ fn aiur_fn_577(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_19, __v_14, __v_15, __v_17, __v_18, __v_16, __v_7]; 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_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 __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));
@@ -49336,7 +49436,7 @@ fn aiur_fn_577(
     break '__mc_0 [__v_26];
   },
   _ => {
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_22, __v_4]; 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_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 __v_26: G = __r_arr[0];
     break '__mc_0 [__v_26];
   },
@@ -49352,9 +49452,9 @@ fn aiur_fn_577(
     break '__mc_1 [__v_28];
   },
   _ => {
-    let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_14, __v_15, __v_17, __v_18, __v_16, __v_3]; 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_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 __v_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_28, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+    let __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 __v_29: G = __r_arr[0];
     break '__mc_1 [__v_29];
   },
@@ -49363,17 +49463,17 @@ fn aiur_fn_577(
                 let __v_28: G = __mc_out___mc_1[0];
                 match __v_28.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_577] = [__v_8];
-                    record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_581] = [__v_8];
+                    record.function_queries[581].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_577] = { let __args: [G; IN_577] = [__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[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_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 __v_31: G = __r_arr[0];
-                    let __ret: [G; OUT_577] = [__v_31];
-                    record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_581] = [__v_31];
+                    record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -49384,10 +49484,10 @@ fn aiur_fn_577(
               0u64 => {
                 let __v_28: G = G::from_u64(1);
                 let __v_29: G = (__v_8 + __v_28);
-                let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__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[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_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 __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_577] = [__v_30];
-                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_581] = [__v_30];
+                record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -49398,10 +49498,10 @@ fn aiur_fn_577(
           _ => {
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__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[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_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 __v_25: G = __r_arr[0];
-            let __ret: [G; OUT_577] = [__v_25];
-            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_581] = [__v_25];
+            record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49413,15 +49513,15 @@ fn aiur_fn_577(
   })
 }
 
-const INPUT_SIZE_578: usize = 3;
-const IN_578: usize = 3;
-const OUT_578: usize = 1;
-fn aiur_fn_578(
-  inp: [G; IN_578],
+const INPUT_SIZE_582: usize = 3;
+const IN_582: usize = 3;
+const OUT_582: usize = 1;
+fn aiur_fn_582(
+  inp: [G; IN_582],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_578], 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];
@@ -49438,12 +49538,12 @@ fn aiur_fn_578(
         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_578] = [__v_11];
-        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_582] = [__v_11];
+        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_4]; 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_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 __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];
@@ -49469,13 +49569,13 @@ fn aiur_fn_578(
  };
         let __v_21: G = __mc_out___mc_0[0];
         let __v_22: G = G::from_u64(0);
-        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_5, __v_6, __v_21, __v_1, __v_2]; 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_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 __v_23: G = __r_arr[0];
-        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 __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 __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_578] = [__v_25];
-        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_582] = [__v_25];
+        record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49485,15 +49585,15 @@ fn aiur_fn_578(
   })
 }
 
-const INPUT_SIZE_579: usize = 2;
-const IN_579: usize = 2;
-const OUT_579: usize = 1;
-fn aiur_fn_579(
-  inp: [G; IN_579],
+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_579], 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];
@@ -49507,7 +49607,7 @@ fn aiur_fn_579(
       0u64 => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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];
@@ -49523,8 +49623,8 @@ fn aiur_fn_579(
             let __v_18: G = __loaded[10];
             match __v_8.as_canonical_u64() {
               6u64 => {
-                let __ret: [G; OUT_579] = [__v_11];
-                record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_583] = [__v_11];
+                record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -49541,15 +49641,15 @@ fn aiur_fn_579(
   })
 }
 
-const INPUT_SIZE_580: usize = 3;
-const IN_580: usize = 3;
-const OUT_580: usize = 1;
-fn aiur_fn_580(
-  inp: [G; IN_580],
+const INPUT_SIZE_584: usize = 3;
+const IN_584: usize = 3;
+const OUT_584: usize = 1;
+fn aiur_fn_584(
+  inp: [G; IN_584],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_580], 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];
@@ -49563,21 +49663,21 @@ fn aiur_fn_580(
         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_580] = [__v_8];
-        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_584] = [__v_8];
+        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 __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 __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_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __v_9]; 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_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 __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_580] = [__v_11];
-        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_584] = [__v_11];
+        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -49587,15 +49687,15 @@ fn aiur_fn_580(
   })
 }
 
-const INPUT_SIZE_581: usize = 4;
-const IN_581: usize = 4;
-const OUT_581: usize = 0;
-fn aiur_fn_581(
-  inp: [G; IN_581],
+const INPUT_SIZE_585: usize = 4;
+const IN_585: usize = 4;
+const OUT_585: usize = 0;
+fn aiur_fn_585(
+  inp: [G; IN_585],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_581], 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];
@@ -49617,8 +49717,8 @@ fn aiur_fn_581(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_581] = [];
-            record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_585] = [];
+            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49639,24 +49739,24 @@ fn aiur_fn_581(
               _ => {
                 match __v_10.as_canonical_u64() {
                   _ => {
+                    let __v_14: G = G::from_u64(1);
+                    let __v_15: G = G::from_u64(1);
+                    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_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 __v_17: G = __r_arr[0];
                     if (__v_5 != __v_10) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
                     }
                     if (__v_6 != __v_11) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
                     }
-                    let __v_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_466] = { let __args: [G; IN_466] = [__v_7, __v_12, __v_16, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
-                    let __v_17: G = __r_arr[0];
                     let __v_18: G = G::from_u64(1);
                     if (__v_17 != __v_18) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
                     }
-                    let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_8, __v_13, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_581] = [];
-                    record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -49675,15 +49775,15 @@ fn aiur_fn_581(
   })
 }
 
-const INPUT_SIZE_582: usize = 13;
-const IN_582: usize = 13;
-const OUT_582: usize = 0;
-fn aiur_fn_582(
-  inp: [G; IN_582],
+const INPUT_SIZE_586: usize = 13;
+const IN_586: usize = 13;
+const OUT_586: usize = 0;
+fn aiur_fn_586(
+  inp: [G; IN_586],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_582], 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];
@@ -49700,7 +49800,7 @@ fn aiur_fn_582(
     let __v_12: G = inp[12];
     match __v_1.as_canonical_u64() {
       6u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_12, __v_4]; 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_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 __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];
@@ -49716,13 +49816,13 @@ fn aiur_fn_582(
         let __v_24: G = __loaded[10];
         match __v_14.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_19, __v_5]; 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_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 __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_582] = [];
-            record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_586] = [];
+            record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -49737,20 +49837,20 @@ fn aiur_fn_582(
   })
 }
 
-const INPUT_SIZE_583: usize = 3;
-const IN_583: usize = 3;
-const OUT_583: usize = 1;
-fn aiur_fn_583(
-  inp: [G; IN_583],
+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_583], ExecError> {
+) -> Result<[G; OUT_587], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __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];
@@ -49766,9 +49866,9 @@ fn aiur_fn_583(
     let __v_14: G = __loaded[10];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1]; 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_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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_15]; 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_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 __v_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(1);
         let __v_18: G = (__v_16 - __v_17);
@@ -49778,31 +49878,31 @@ fn aiur_fn_583(
             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_504] = { let __args: [G; IN_504] = [__v_6, __v_19, __v_22, __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 __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 __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_225] = { let __args: [G; IN_225] = [__v_23, __v_26]; 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_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 __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_583] = [__v_28];
-                record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_587] = [__v_28];
+                record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_777] = { let __args: [G; IN_777] = [__v_9, __v_31]; 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_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 __v_32: G = __r_arr[0];
-                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_32]; 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_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 __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];
@@ -49819,22 +49919,22 @@ fn aiur_fn_583(
                     match __v_34.as_canonical_u64() {
                       6u64 => {
                         let __v_45: G = G::from_bool((__v_40 == G::ZERO));
-                        let __ret: [G; OUT_583] = [__v_45];
-                        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_587] = [__v_45];
+                        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_45: G = G::from_u64(0);
-                        let __ret: [G; OUT_583] = [__v_45];
-                        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_587] = [__v_45];
+                        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_31: G = G::from_u64(0);
-                    let __ret: [G; OUT_583] = [__v_31];
-                    record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_587] = [__v_31];
+                    record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -49846,31 +49946,31 @@ fn aiur_fn_583(
           },
           _ => {
             let __v_19: G = G::from_u64(0);
-            let __ret: [G; OUT_583] = [__v_19];
-            record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_587] = [__v_19];
+            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_583] = [__v_15];
-        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_587] = [__v_15];
+        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_584: usize = 2;
-const IN_584: usize = 2;
-const OUT_584: usize = 1;
-fn aiur_fn_584(
-  inp: [G; IN_584],
+const INPUT_SIZE_588: usize = 2;
+const IN_588: usize = 2;
+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_584], 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];
@@ -49894,22 +49994,22 @@ fn aiur_fn_584(
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_584] = [__v_13];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_13];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_584] = [__v_13];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_13];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_10];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_10];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49923,14 +50023,14 @@ fn aiur_fn_584(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_584] = [__v_10];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_10];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_10];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_10];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49949,22 +50049,22 @@ fn aiur_fn_584(
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_584] = [__v_13];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_13];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_584] = [__v_13];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_13];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_10];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_10];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -49977,28 +50077,28 @@ fn aiur_fn_584(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_7]; 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_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 __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
+                let __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 __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_584] = [__v_11];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_11];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_584] = [__v_11];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_11];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_10];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_10];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50011,28 +50111,28 @@ fn aiur_fn_584(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_7]; 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_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 __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
+                let __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 __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_584] = [__v_11];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_11];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_584] = [__v_11];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_11];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_10];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_10];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50045,51 +50145,51 @@ fn aiur_fn_584(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_7]; 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_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 __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
+                let __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 __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_584] = [__v_11];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_11];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_584] = [__v_11];
-                record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_588] = [__v_11];
+                record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_584] = [__v_10];
-            record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_588] = [__v_10];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_584] = [__v_6];
-        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_588] = [__v_6];
+        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_585: usize = 8;
-const IN_585: usize = 8;
-const OUT_585: usize = 1;
-fn aiur_fn_585(
-  inp: [G; IN_585],
+const INPUT_SIZE_589: usize = 8;
+const IN_589: usize = 8;
+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_585], 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];
@@ -50099,7 +50199,7 @@ fn aiur_fn_585(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_7, __v_5]; 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_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 __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];
@@ -50115,35 +50215,35 @@ fn aiur_fn_585(
     let __v_19: G = __loaded[10];
     match __v_9.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
+        let __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 __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_586] = { let __args: [G; IN_586] = [__v_6, __v_5, __v_20, __v_21, __v_22]; 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_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 __v_23: G = __r_arr[0];
-        let __ret: [G; OUT_585] = [__v_23];
-        record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_589] = [__v_23];
+        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_20: G = G::from_u64(0);
-        let __ret: [G; OUT_585] = [__v_20];
-        record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_589] = [__v_20];
+        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_586: usize = 5;
-const IN_586: usize = 5;
-const OUT_586: usize = 1;
-fn aiur_fn_586(
-  inp: [G; IN_586],
+const INPUT_SIZE_590: usize = 5;
+const IN_590: usize = 5;
+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_586], 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];
@@ -50162,15 +50262,15 @@ fn aiur_fn_586(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_586] = [__v_11];
-            record.function_queries[586].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);
           },
           _ => {
             let __v_11: G = G::from_u64(1);
             let __v_12: G = (__v_4 - __v_11);
-            let __ret: [G; OUT_586] = [__v_12];
-            record.function_queries[586].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);
           },
         }
@@ -50195,26 +50295,26 @@ fn aiur_fn_586(
             let __v_14: G = __mc_out___mc_0[0];
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_586] = [__v_3];
-                record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_590] = [__v_3];
+                record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+                let __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 __v_15: G = __r_arr[0];
                 match __v_15.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_586] = [__v_3];
-                    record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_590] = [__v_3];
+                    record.function_queries[590].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_586] = { let __args: [G; IN_586] = [__v_10, __v_1, __v_2, __v_17, __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 __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 __v_18: G = __r_arr[0];
-                    let __ret: [G; OUT_586] = [__v_18];
-                    record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_590] = [__v_18];
+                    record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -50227,10 +50327,10 @@ fn aiur_fn_586(
           _ => {
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_10, __v_1, __v_2, __v_15, __v_4]; 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_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 __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_586] = [__v_16];
-            record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_590] = [__v_16];
+            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50242,15 +50342,15 @@ fn aiur_fn_586(
   })
 }
 
-const INPUT_SIZE_587: usize = 14;
-const IN_587: usize = 14;
-const OUT_587: usize = 0;
-fn aiur_fn_587(
-  inp: [G; IN_587],
+const INPUT_SIZE_591: usize = 14;
+const IN_591: usize = 14;
+const OUT_591: usize = 0;
+fn aiur_fn_591(
+  inp: [G; IN_591],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_587], 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];
@@ -50268,17 +50368,14 @@ fn aiur_fn_587(
     let __v_13: G = inp[13];
     match __v_1.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_14, __v_12, __v_13]; 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_621] = { let __args: [G; IN_621] = [__v_14, __v_11, __v_12]; 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_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 __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_14, __v_12, __v_13]; 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 __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 __v_16: G = __r_arr[0];
-        if (__v_9 != __v_16) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_12, __v_15]; 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_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 __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];
@@ -50292,7 +50389,7 @@ fn aiur_fn_587(
         let __v_26: G = __loaded[8];
         let __v_27: G = __loaded[9];
         let __v_28: G = __loaded[10];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_12, __v_14]; 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_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 __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];
@@ -50306,6 +50403,9 @@ fn aiur_fn_587(
         let __v_38: G = __loaded[8];
         let __v_39: G = __loaded[9];
         let __v_40: G = __loaded[10];
+        if (__v_9 != __v_16) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
+        }
         match __v_18.as_canonical_u64() {
           5u64 => {
             match __v_30.as_canonical_u64() {
@@ -50314,9 +50414,9 @@ fn aiur_fn_587(
                 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_504] = { let __args: [G; IN_504] = [__v_32, __v_41, __v_44, __v_12, __v_13]; 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 __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 __v_45: G = __r_arr[0];
-                let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_45, __v_35, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+                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 __v_46: G = __r_arr[0];
                 let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_46.as_canonical_u64() {
   1u64 => {
@@ -50338,59 +50438,59 @@ fn aiur_fn_587(
 }
  };
                 let __v_47: G = __mc_out___mc_0[0];
-                let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_15, __v_12]; 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_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 __v_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_48, __v_46, __v_12, __v_13]; 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_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 __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__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[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 __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 __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__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[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_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 __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_466] = { let __args: [G; IN_466] = [__v_3, __v_51, __v_54, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
+                let __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 __v_55: G = __r_arr[0];
-                let __v_56: G = G::from_u64(1);
-                if (__v_55 != __v_56) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
-                }
-                let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_49]; 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_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 __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 __v_57: G = __r_arr[0];
-                let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_49]; 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_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 __v_58: G = __r_arr[0];
-                let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_49, __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_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 __v_59: G = __r_arr[0];
-                let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__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[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_60: G = __r_arr[0];
-                let __v_61: G = G::from_u64(0);
-                let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_49, __v_57, __v_59, __v_21, __v_58, __v_19, __v_46, __v_21, __v_12, __v_13, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } };
+                let __v_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 __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 __v_62: G = __r_arr[0];
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_62]; 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_63: G = __r_arr[0];
-                let __v_64: G = G::from_u64(0);
-                let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_57, __v_50, __v_12, __v_64]; 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_65: G = __r_arr[0];
-                let __v_66: G = G::from_u64(0);
-                let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_46, __v_19, __v_66]; 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_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 __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 __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 __v_67: G = __r_arr[0];
-                let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_20, __v_67]; 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_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 __v_68: G = __r_arr[0];
-                let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_68, __v_21]; 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_69: G = __r_arr[0];
-                let __v_70: G = __r_arr[1];
-                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_49, __v_11, __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 __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 __v_71: G = __r_arr[0];
-                let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_49, __v_50]; 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_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 __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_635] = { let __args: [G; IN_635] = [__v_0, __v_14, __v_35, __v_21, __v_58, __v_63, __v_19, __v_46, __v_60, __v_62, __v_69, __v_71, __v_49, __v_57, __v_59, __v_73, __v_74, __v_75, __v_12, __v_13, __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 __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 __v_76: G = __r_arr[0];
-                let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_8, __v_76, __v_12, __v_13]; 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 __ret: [G; OUT_587] = [];
-                record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -50410,43 +50510,43 @@ fn aiur_fn_587(
   })
 }
 
-const INPUT_SIZE_588: usize = 4;
-const IN_588: usize = 4;
-const OUT_588: usize = 1;
-fn aiur_fn_588(
-  inp: [G; IN_588],
+const INPUT_SIZE_592: usize = 4;
+const IN_592: usize = 4;
+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_588], ExecError> {
+) -> Result<[G; OUT_592], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1, __v_2]; 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_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 __v_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_4, __v_5, __v_0, __v_2, __v_3]; 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_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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_6]; 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_797] = { let __args: [G; IN_797] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[797].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_797] = unsafe { *(result.output.as_ptr() as *const [G; OUT_797]) }; __ret } else { aiur_fn_797(__args, record, io_buffer, __cu)? } };
     let __v_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_588] = [__v_6];
-        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_592] = [__v_6];
+        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_6, __v_7, __v_2, __v_3]; 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_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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_588] = [__v_12];
-        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_592] = [__v_12];
+        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -50456,61 +50556,61 @@ fn aiur_fn_588(
   })
 }
 
-const INPUT_SIZE_589: usize = 5;
-const IN_589: usize = 5;
-const OUT_589: usize = 1;
-fn aiur_fn_589(
-  inp: [G; IN_589],
+const INPUT_SIZE_593: usize = 5;
+const IN_593: usize = 5;
+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_589], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_0]; 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_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 __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_589] = [__v_0];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_593] = [__v_0];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_1]; 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_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 __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_590] = { let __args: [G; IN_590] = [__v_7, __v_8, __v_9, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
+        let __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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_11]; 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_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 __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_589] = { let __args: [G; IN_589] = [__v_12, __v_14, __v_2, __v_3, __v_4]; 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_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 __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_589] = [__v_15];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_593] = [__v_15];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_590: usize = 7;
-const IN_590: usize = 7;
-const OUT_590: usize = 1;
-fn aiur_fn_590(
-  inp: [G; IN_590],
+const INPUT_SIZE_594: usize = 7;
+const IN_594: usize = 7;
+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_590], 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];
@@ -50519,7 +50619,7 @@ fn aiur_fn_590(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_5, __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_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 __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];
@@ -50535,33 +50635,33 @@ fn aiur_fn_590(
     let __v_18: G = __loaded[10];
     match __v_8.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__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[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 __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 __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_590] = [__v_19];
-        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_594] = [__v_19];
+        record.function_queries[594].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_590] = [__v_21];
-        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_594] = [__v_21];
+        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_591: usize = 8;
-const IN_591: usize = 8;
-const OUT_591: usize = 1;
-fn aiur_fn_591(
-  inp: [G; IN_591],
+const INPUT_SIZE_595: usize = 8;
+const IN_595: usize = 8;
+const OUT_595: usize = 1;
+fn aiur_fn_595(
+  inp: [G; IN_595],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_591], 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];
@@ -50580,12 +50680,12 @@ fn aiur_fn_591(
         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_591] = [__v_13];
-        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_595] = [__v_13];
+        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_6, __v_9]; 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_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 __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];
@@ -50603,12 +50703,12 @@ fn aiur_fn_591(
           6u64 => {
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_14, __v_1]; 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_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 __v_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
   _ => {
-    let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_14, __v_1, __v_3, __v_4, __v_6, __v_7]; 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_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 __v_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
@@ -50616,21 +50716,21 @@ fn aiur_fn_591(
  };
             let __v_23: G = __mc_out___mc_0[0];
             let __v_24: G = G::from_u64(0);
-            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_23, __v_5, __v_6, __v_24]; 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_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 __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__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[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 __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 __v_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_25, __v_26]; 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_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 __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_591] = [__v_27];
-            record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_595] = [__v_27];
+            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__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[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 __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 __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_591] = [__v_23];
-            record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_595] = [__v_23];
+            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50642,15 +50742,15 @@ fn aiur_fn_591(
   })
 }
 
-const INPUT_SIZE_592: usize = 2;
-const IN_592: usize = 2;
-const OUT_592: usize = 1;
-fn aiur_fn_592(
-  inp: [G; IN_592],
+const INPUT_SIZE_596: usize = 2;
+const IN_596: usize = 2;
+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_592], 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];
@@ -50662,19 +50762,19 @@ fn aiur_fn_592(
     let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_592] = [__v_0];
-        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_596] = [__v_0];
+        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __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_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 __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_6]; 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_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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_592] = [__v_8];
-            record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_596] = [__v_8];
+            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -50684,12 +50784,12 @@ fn aiur_fn_592(
             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_782] = { let __args: [G; IN_782] = [__v_0, __v_13]; 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_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 __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_14, __v_6]; 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_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 __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_592] = [__v_15];
-            record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_596] = [__v_15];
+            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50701,15 +50801,15 @@ fn aiur_fn_592(
   })
 }
 
-const INPUT_SIZE_593: usize = 3;
-const IN_593: usize = 3;
-const OUT_593: usize = 1;
-fn aiur_fn_593(
-  inp: [G; IN_593],
+const INPUT_SIZE_597: usize = 3;
+const IN_597: usize = 3;
+const OUT_597: usize = 1;
+fn aiur_fn_597(
+  inp: [G; IN_597],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_593], 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];
@@ -50724,8 +50824,8 @@ fn aiur_fn_593(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_593] = [__v_9];
-        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_597] = [__v_9];
+        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -50737,25 +50837,25 @@ fn aiur_fn_593(
             match __v_5.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(1);
-                let __ret: [G; OUT_593] = [__v_12];
-                record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_597] = [__v_12];
+                record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+                let __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 __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_593] = [__v_13];
-                    record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_597] = [__v_13];
+                    record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_1, __v_2]; 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_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 __v_13: G = __r_arr[0];
-                    let __ret: [G; OUT_593] = [__v_13];
-                    record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_597] = [__v_13];
+                    record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -50766,10 +50866,10 @@ fn aiur_fn_593(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_1, __v_2]; 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_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 __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_593] = [__v_12];
-            record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_597] = [__v_12];
+            record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50781,15 +50881,15 @@ fn aiur_fn_593(
   })
 }
 
-const INPUT_SIZE_594: usize = 2;
-const IN_594: usize = 2;
-const OUT_594: usize = 1;
-fn aiur_fn_594(
-  inp: [G; IN_594],
+const INPUT_SIZE_598: usize = 2;
+const IN_598: usize = 2;
+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_594], 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];
@@ -50806,14 +50906,14 @@ fn aiur_fn_594(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_594] = [__v_8];
-            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_598] = [__v_8];
+            record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_594] = [__v_8];
-            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_598] = [__v_8];
+            record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -50829,24 +50929,24 @@ fn aiur_fn_594(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_594] = [__v_8];
-            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_598] = [__v_8];
+            record.function_queries[598].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_594] = { let __args: [G; IN_594] = [__v_4, __v_7]; 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_598] = { let __args: [G; IN_598] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_594] = [__v_9];
-                record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_598] = [__v_9];
+                record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_594] = [__v_9];
-                record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_598] = [__v_9];
+                record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -50863,15 +50963,15 @@ fn aiur_fn_594(
   })
 }
 
-const INPUT_SIZE_595: usize = 3;
-const IN_595: usize = 3;
-const OUT_595: usize = 1;
-fn aiur_fn_595(
-  inp: [G; IN_595],
+const INPUT_SIZE_599: usize = 3;
+const IN_599: usize = 3;
+const OUT_599: usize = 1;
+fn aiur_fn_599(
+  inp: [G; IN_599],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_595], 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];
@@ -50885,12 +50985,12 @@ fn aiur_fn_595(
         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_595] = [__v_8];
-        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_599] = [__v_8];
+        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_4]; 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_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 __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];
@@ -50907,18 +51007,18 @@ fn aiur_fn_595(
         match __v_7.as_canonical_u64() {
           5u64 => {
             let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_8, __v_18]; 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_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 __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_595] = { let __args: [G; IN_595] = [__v_5, __v_1, __v_2]; 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_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 __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_595] = [__v_26];
-            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_26];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -50930,11 +51030,11 @@ fn aiur_fn_595(
             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_595] = { let __args: [G; IN_595] = [__v_5, __v_1, __v_2]; 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_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 __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_595] = [__v_27];
-            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_599] = [__v_27];
+            record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -50946,15 +51046,15 @@ fn aiur_fn_595(
   })
 }
 
-const INPUT_SIZE_596: usize = 1;
-const IN_596: usize = 1;
-const OUT_596: usize = 1;
-fn aiur_fn_596(
-  inp: [G; IN_596],
+const INPUT_SIZE_600: usize = 1;
+const IN_600: usize = 1;
+const OUT_600: usize = 1;
+fn aiur_fn_600(
+  inp: [G; IN_600],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_596], ExecError> {
+) -> Result<[G; OUT_600], 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 };
@@ -50969,17 +51069,17 @@ fn aiur_fn_596(
         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_596] = [__v_9];
-        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_600] = [__v_9];
+        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__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_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 __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_596] = [__v_9];
-        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_600] = [__v_9];
+        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -50989,15 +51089,15 @@ fn aiur_fn_596(
   })
 }
 
-const INPUT_SIZE_597: usize = 2;
-const IN_597: usize = 2;
-const OUT_597: usize = 4;
-fn aiur_fn_597(
-  inp: [G; IN_597],
+const INPUT_SIZE_601: usize = 2;
+const IN_601: usize = 2;
+const OUT_601: usize = 4;
+fn aiur_fn_601(
+  inp: [G; IN_601],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_597], 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];
@@ -51018,27 +51118,27 @@ fn aiur_fn_597(
         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_597] = [__v_8, __v_9, __v_12, __v_15];
-        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_601] = [__v_8, __v_9, __v_12, __v_15];
+        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_597] = [__v_3, __v_4, __v_5, __v_6];
-            record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_601] = [__v_3, __v_4, __v_5, __v_6];
+            record.function_queries[601].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_597] = { let __args: [G; IN_597] = [__v_7, __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 __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 __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_597] = [__v_10, __v_11, __v_12, __v_13];
-            record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_601] = [__v_10, __v_11, __v_12, __v_13];
+            record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51050,31 +51150,31 @@ fn aiur_fn_597(
   })
 }
 
-const INPUT_SIZE_598: usize = 4;
-const IN_598: usize = 4;
-const OUT_598: usize = 1;
-fn aiur_fn_598(
-  inp: [G; IN_598],
+const INPUT_SIZE_602: usize = 4;
+const IN_602: usize = 4;
+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_598], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    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_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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0, __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_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 __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_6]; 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_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 __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_777] = { let __args: [G; IN_777] = [__v_2, __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_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 __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];
@@ -51090,16 +51190,16 @@ fn aiur_fn_598(
     let __v_22: G = __loaded[10];
     match __v_12.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_14, __v_15]; 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_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 __v_23: G = __r_arr[0];
         let __v_24: G = __r_arr[1];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_5]; 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_797] = { let __args: [G; IN_797] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[797].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_797] = unsafe { *(result.output.as_ptr() as *const [G; OUT_797]) }; __ret } else { aiur_fn_797(__args, record, io_buffer, __cu)? } };
         let __v_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_599] = { let __args: [G; IN_599] = [__v_28, __v_26]; 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_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 __v_29: G = __r_arr[0];
         let __v_30: G = G::from_u64(1);
         let __v_31: G = G::from_u64(1);
@@ -51107,36 +51207,36 @@ fn aiur_fn_598(
         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_601] = { let __args: [G; IN_601] = [__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[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_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 __v_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_36]; 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_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 __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_37, __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 __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 __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_38]; 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_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 __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_598] = [__v_39];
-        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_602] = [__v_39];
+        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_598] = [__v_0];
-        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_602] = [__v_0];
+        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_599: usize = 2;
-const IN_599: usize = 2;
-const OUT_599: usize = 1;
-fn aiur_fn_599(
-  inp: [G; IN_599],
+const INPUT_SIZE_603: usize = 2;
+const IN_603: usize = 2;
+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_599], 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];
@@ -51146,34 +51246,34 @@ fn aiur_fn_599(
         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_599] = [__v_5];
-        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_603] = [__v_5];
+        record.function_queries[603].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_599] = { let __args: [G; IN_599] = [__v_5, __v_1]; 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_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 __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_599] = [__v_7];
-        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_603] = [__v_7];
+        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_600: usize = 2;
-const IN_600: usize = 2;
-const OUT_600: usize = 1;
-fn aiur_fn_600(
-  inp: [G; IN_600],
+const INPUT_SIZE_604: usize = 2;
+const IN_604: usize = 2;
+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_600], 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];
@@ -51186,22 +51286,22 @@ fn aiur_fn_600(
         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_600] = [__v_7];
-        record.function_queries[600].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);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_1, __v_3]; 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_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 __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_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; 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_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 __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_600] = [__v_11];
-        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_604] = [__v_11];
+        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51211,15 +51311,15 @@ fn aiur_fn_600(
   })
 }
 
-const INPUT_SIZE_601: usize = 9;
-const IN_601: usize = 9;
-const OUT_601: usize = 1;
-fn aiur_fn_601(
-  inp: [G; IN_601],
+const INPUT_SIZE_605: usize = 9;
+const IN_605: usize = 9;
+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_601], 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];
@@ -51232,31 +51332,31 @@ fn aiur_fn_601(
     let __v_8: G = inp[8];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_601] = [__v_0];
-        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_605] = [__v_0];
+        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_5, __v_9]; 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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__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[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_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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_11]; 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_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 __v_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_601] = [__v_0];
-            record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_605] = [__v_0];
+            record.function_queries[605].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_601] = { let __args: [G; IN_601] = [__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[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_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 __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_601] = [__v_15];
-            record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_605] = [__v_15];
+            record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51265,15 +51365,15 @@ fn aiur_fn_601(
   })
 }
 
-const INPUT_SIZE_602: usize = 3;
-const IN_602: usize = 3;
-const OUT_602: usize = 1;
-fn aiur_fn_602(
-  inp: [G; IN_602],
+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_602], 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];
@@ -51287,21 +51387,21 @@ fn aiur_fn_602(
         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_602] = [__v_8];
-        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_606] = [__v_8];
+        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_4, __v_1, __v_2]; 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_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];
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_1, __v_8]; 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_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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_6, __v_9]; 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_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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_602] = [__v_10];
-        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_606] = [__v_10];
+        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51311,15 +51411,15 @@ fn aiur_fn_602(
   })
 }
 
-const INPUT_SIZE_603: usize = 3;
-const IN_603: usize = 3;
-const OUT_603: usize = 1;
-fn aiur_fn_603(
-  inp: [G; IN_603],
+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_603], 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];
@@ -51333,18 +51433,18 @@ fn aiur_fn_603(
         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_603] = [__v_8];
-        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_607] = [__v_8];
+        record.function_queries[607].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_603] = { let __args: [G; IN_603] = [__v_5, __v_1, __v_2]; 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_607] = { let __args: [G; IN_607] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } };
         let __v_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_603] = [__v_9];
-        record.function_queries[603].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);
       },
       _ => {
@@ -51354,15 +51454,15 @@ fn aiur_fn_603(
   })
 }
 
-const INPUT_SIZE_604: usize = 9;
-const IN_604: usize = 9;
-const OUT_604: usize = 1;
-fn aiur_fn_604(
-  inp: [G; IN_604],
+const INPUT_SIZE_608: usize = 9;
+const IN_608: usize = 9;
+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_604], 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];
@@ -51382,19 +51482,19 @@ fn aiur_fn_604(
         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_604] = [__v_14];
-        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_608] = [__v_14];
+        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__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[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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__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[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_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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_604] = [__v_14];
-        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_608] = [__v_14];
+        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51404,15 +51504,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_609: usize = 9;
+const IN_609: usize = 9;
+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_605], 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];
@@ -51423,15 +51523,15 @@ fn aiur_fn_605(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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_605] = [__v_12];
-        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_609] = [__v_12];
+        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -51440,32 +51540,32 @@ fn aiur_fn_605(
         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_605] = [__v_14];
-        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_609] = [__v_14];
+        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__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[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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__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[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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_605] = [__v_11];
-        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_609] = [__v_11];
+        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_606: usize = 9;
-const IN_606: usize = 9;
-const OUT_606: usize = 1;
-fn aiur_fn_606(
-  inp: [G; IN_606],
+const INPUT_SIZE_610: usize = 9;
+const IN_610: usize = 9;
+const OUT_610: usize = 1;
+fn aiur_fn_610(
+  inp: [G; IN_610],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_606], 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];
@@ -51485,17 +51585,17 @@ fn aiur_fn_606(
         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_606] = [__v_14];
-        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_610] = [__v_14];
+        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__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[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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__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[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_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 __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_606] = [__v_13];
-        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_610] = [__v_13];
+        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -51505,15 +51605,15 @@ fn aiur_fn_606(
   })
 }
 
-const INPUT_SIZE_607: usize = 10;
-const IN_607: usize = 10;
-const OUT_607: usize = 1;
-fn aiur_fn_607(
-  inp: [G; IN_607],
+const INPUT_SIZE_611: usize = 10;
+const IN_611: usize = 10;
+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_607], 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];
@@ -51536,29 +51636,29 @@ fn aiur_fn_607(
         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_607] = [__v_17];
-        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_611] = [__v_17];
+        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__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[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_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 __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_607] = { let __args: [G; IN_607] = [__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[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_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 __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_607] = [__v_17];
-            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_611] = [__v_17];
+            record.function_queries[611].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_607] = [__v_16];
-            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_611] = [__v_16];
+            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51570,15 +51670,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_612: usize = 9;
+const IN_612: usize = 9;
+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_608], 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];
@@ -51598,8 +51698,8 @@ 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_612] = [__v_14];
+        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -51608,10 +51708,10 @@ fn aiur_fn_608(
         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_609] = { let __args: [G; IN_609] = [__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[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_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 __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_608] = [__v_17];
-        record.function_queries[608].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);
       },
       _ => {
@@ -51621,15 +51721,15 @@ fn aiur_fn_608(
   })
 }
 
-const INPUT_SIZE_609: usize = 11;
-const IN_609: usize = 11;
-const OUT_609: usize = 1;
-fn aiur_fn_609(
-  inp: [G; IN_609],
+const INPUT_SIZE_613: usize = 11;
+const IN_613: usize = 11;
+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_609], 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];
@@ -51653,22 +51753,22 @@ fn aiur_fn_609(
         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_609] = [__v_18];
-        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_613] = [__v_18];
+        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__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[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_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 __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_769] = { let __args: [G; IN_769] = [__v_10, __v_12]; 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 __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 __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__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[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_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 __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_609] = [__v_17];
-            record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_613] = [__v_17];
+            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -51678,11 +51778,11 @@ fn aiur_fn_609(
             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_609] = { let __args: [G; IN_609] = [__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[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_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 __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_609] = [__v_23];
-            record.function_queries[609].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);
           },
         }
@@ -51694,15 +51794,15 @@ fn aiur_fn_609(
   })
 }
 
-const INPUT_SIZE_610: usize = 10;
-const IN_610: usize = 10;
-const OUT_610: usize = 2;
-fn aiur_fn_610(
-  inp: [G; IN_610],
+const INPUT_SIZE_614: usize = 10;
+const IN_614: usize = 10;
+const OUT_614: usize = 2;
+fn aiur_fn_614(
+  inp: [G; IN_614],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_610], 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];
@@ -51714,17 +51814,17 @@ fn aiur_fn_610(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_3, __v_0]; 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_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 __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_597] = { let __args: [G; IN_597] = [__v_3, __v_1]; 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_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 __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_777] = { let __args: [G; IN_777] = [__v_8, __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_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 __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];
@@ -51738,7 +51838,7 @@ fn aiur_fn_610(
     let __v_27: G = __loaded[8];
     let __v_28: G = __loaded[9];
     let __v_29: G = __loaded[10];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_14]; 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_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 __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];
@@ -51756,74 +51856,74 @@ fn aiur_fn_610(
       5u64 => {
         match __v_31.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_23, __v_35]; 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_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 __v_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_42]; 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_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 __v_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_24]; 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_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 __v_45: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_36]; 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_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 __v_46: G = __r_arr[0];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+            let __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 __v_47: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_47]; 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_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 __v_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__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[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_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 __v_50: G = __r_arr[0];
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__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[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_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 __v_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_50, __v_51, __v_2, __v_9]; 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_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 __v_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__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[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_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 __v_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_52, __v_53, __v_54, __v_55]; 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 __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 __v_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_48, __v_49, __v_56, __v_57]; 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 __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 __v_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_43, __v_44, __v_58, __v_59]; 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 __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 __v_60: G = __r_arr[0];
             let __v_61: G = __r_arr[1];
-            let __ret: [G; OUT_610] = [__v_60, __v_61];
-            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_614] = [__v_60, __v_61];
+            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __ret: [G; OUT_610] = [__v_42, __v_43];
-            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_614] = [__v_42, __v_43];
+            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_42: G = __r_arr[0];
         let __v_43: G = __r_arr[1];
-        let __ret: [G; OUT_610] = [__v_42, __v_43];
-        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_614] = [__v_42, __v_43];
+        record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_611: usize = 11;
-const IN_611: usize = 11;
-const OUT_611: usize = 1;
-fn aiur_fn_611(
-  inp: [G; IN_611],
+const INPUT_SIZE_615: usize = 11;
+const IN_615: usize = 11;
+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_611], 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];
@@ -51836,31 +51936,31 @@ fn aiur_fn_611(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+    let __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 __v_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_11, __v_1, __v_2, __v_12, __v_9, __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_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 __v_13: G = __r_arr[0];
     let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_13, __v_4, __v_5, __v_6, __v_8, __v_14]; 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_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 __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_15, __v_7]; 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_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 __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_611] = [__v_16];
-    record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_615] = [__v_16];
+    record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_612: usize = 16;
-const IN_612: usize = 16;
-const OUT_612: usize = 2;
-fn aiur_fn_612(
-  inp: [G; IN_612],
+const INPUT_SIZE_616: usize = 16;
+const IN_616: usize = 16;
+const OUT_616: usize = 2;
+fn aiur_fn_616(
+  inp: [G; IN_616],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_612], 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];
@@ -51884,11 +51984,11 @@ fn aiur_fn_612(
     let __v_18: G = __loaded[2];
     match __v_16.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __ret: [G; OUT_612] = [__v_19, __v_20];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_616] = [__v_19, __v_20];
+        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -51898,15 +51998,15 @@ fn aiur_fn_612(
         let __v_21: G = __loaded[2];
         match __v_19.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
-            let __ret: [G; OUT_612] = [__v_22, __v_23];
-            record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_616] = [__v_22, __v_23];
+            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_14, __v_17]; 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_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 __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];
@@ -51920,7 +52020,7 @@ fn aiur_fn_612(
             let __v_31: G = __loaded[8];
             let __v_32: G = __loaded[9];
             let __v_33: G = __loaded[10];
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_14, __v_20]; 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_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 __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];
@@ -51938,47 +52038,47 @@ fn aiur_fn_612(
               6u64 => {
                 match __v_35.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_29, __v_41]; 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_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 __v_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_46]; 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_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 __v_47: G = __r_arr[0];
                     let __v_48: G = __r_arr[1];
-                    let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__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[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_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 __v_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__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[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_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 __v_50: G = __r_arr[0];
-                    let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_49, __v_50, __v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+                    let __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 __v_51: G = __r_arr[0];
                     let __v_52: G = __r_arr[1];
-                    let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__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[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_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 __v_53: G = __r_arr[0];
                     let __v_54: G = __r_arr[1];
-                    let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_51, __v_52, __v_53, __v_54]; 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 __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 __v_55: G = __r_arr[0];
                     let __v_56: G = __r_arr[1];
-                    let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_47, __v_48, __v_55, __v_56]; 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 __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 __v_57: G = __r_arr[0];
                     let __v_58: G = __r_arr[1];
-                    let __ret: [G; OUT_612] = [__v_57, __v_58];
-                    record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_616] = [__v_57, __v_58];
+                    record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_46: G = __r_arr[0];
                     let __v_47: G = __r_arr[1];
-                    let __ret: [G; OUT_612] = [__v_46, __v_47];
-                    record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_616] = [__v_46, __v_47];
+                    record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_46: G = __r_arr[0];
                 let __v_47: G = __r_arr[1];
-                let __ret: [G; OUT_612] = [__v_46, __v_47];
-                record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_616] = [__v_46, __v_47];
+                record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -51995,15 +52095,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_617: usize = 11;
+const IN_617: usize = 11;
+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_613], 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];
@@ -52016,28 +52116,28 @@ fn aiur_fn_613(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_2, __v_3, __v_9, __v_10]; 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_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 __v_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_11, __v_4, __v_5, __v_6, __v_8, __v_12]; 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_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 __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_13, __v_7]; 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_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 __v_14: G = __r_arr[0];
-    let __ret: [G; OUT_613] = [__v_14];
-    record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_617] = [__v_14];
+    record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_614: usize = 6;
-const IN_614: usize = 6;
-const OUT_614: usize = 1;
-fn aiur_fn_614(
-  inp: [G; IN_614],
+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_614], 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];
@@ -52045,13 +52145,13 @@ fn aiur_fn_614(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_614] = [__v_7];
-        record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_618] = [__v_7];
+        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52063,71 +52163,71 @@ fn aiur_fn_614(
         match __v_8.as_canonical_u64() {
           3u64 => {
             let __v_12: G = G::from_u64(3);
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __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_614] = [__v_16];
-            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_618] = [__v_16];
+            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_12: G = G::from_u64(4);
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __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_614] = { let __args: [G; IN_614] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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_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 __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_614] = [__v_18];
-            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_618] = [__v_18];
+            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             let __v_12: G = G::from_u64(5);
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __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_614] = { let __args: [G; IN_614] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; 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_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 __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_614] = [__v_18];
-            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_618] = [__v_18];
+            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
             let __v_12: G = G::from_u64(6);
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __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_614] = { let __args: [G; IN_614] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_16]; 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_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 __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_614] = [__v_18];
-            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_618] = [__v_18];
+            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           8u64 => {
             let __v_12: G = G::from_u64(8);
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_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 __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_614] = [__v_14];
-            record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_618] = [__v_14];
+            record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_614] = [__v_0];
-            record.function_queries[614].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);
           },
         }
@@ -52136,15 +52236,15 @@ fn aiur_fn_614(
   })
 }
 
-const INPUT_SIZE_615: usize = 6;
-const IN_615: usize = 6;
-const OUT_615: usize = 2;
-fn aiur_fn_615(
-  inp: [G; IN_615],
+const INPUT_SIZE_619: usize = 6;
+const IN_619: usize = 6;
+const OUT_619: usize = 2;
+fn aiur_fn_619(
+  inp: [G; IN_619],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_615], 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];
@@ -52152,7 +52252,7 @@ fn aiur_fn_615(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; 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_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_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 };
@@ -52163,32 +52263,32 @@ fn aiur_fn_615(
     match __v_8.as_canonical_u64() {
       2u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__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[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_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 __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_615] = [__v_13, __v_14];
-        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_619] = [__v_13, __v_14];
+        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_615] = [__v_12, __v_0];
-        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_619] = [__v_12, __v_0];
+        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_616: usize = 9;
-const IN_616: usize = 9;
-const OUT_616: usize = 2;
-fn aiur_fn_616(
-  inp: [G; IN_616],
+const INPUT_SIZE_620: usize = 9;
+const IN_620: usize = 9;
+const OUT_620: usize = 2;
+fn aiur_fn_620(
+  inp: [G; IN_620],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_616], 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];
@@ -52209,42 +52309,42 @@ fn aiur_fn_616(
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_616] = [__v_15, __v_0];
-        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_620] = [__v_15, __v_0];
+        record.function_queries[620].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_196] = { let __args: [G; IN_196] = [__v_12]; 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_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 __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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_616] = { let __args: [G; IN_616] = [__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[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_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 __v_21: G = __r_arr[0];
                 let __v_22: G = __r_arr[1];
-                let __ret: [G; OUT_616] = [__v_21, __v_22];
-                record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_620] = [__v_21, __v_22];
+                record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_2, __v_12, __v_7]; 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_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 __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_616] = { let __args: [G; IN_616] = [__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[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_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 __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_620] = [__v_22, __v_23];
+                    record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
@@ -52253,15 +52353,15 @@ fn aiur_fn_616(
                     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_618] = { let __args: [G; IN_618] = [__v_23, __v_5, __v_7, __v_24]; 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_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 __v_25: G = __r_arr[0];
                     let __v_26: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_2, __v_16]; 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_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 __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_25, __v_27]; 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_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 __v_28: G = __r_arr[0];
-                    let __ret: [G; OUT_616] = [__v_26, __v_28];
-                    record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_620] = [__v_26, __v_28];
+                    record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -52277,11 +52377,11 @@ fn aiur_fn_616(
           _ => {
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_8 + __v_16);
-            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__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[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_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 __v_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_616] = [__v_18, __v_19];
-            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_620] = [__v_18, __v_19];
+            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52293,15 +52393,15 @@ fn aiur_fn_616(
   })
 }
 
-const INPUT_SIZE_617: usize = 3;
-const IN_617: usize = 3;
-const OUT_617: usize = 1;
-fn aiur_fn_617(
-  inp: [G; IN_617],
+const INPUT_SIZE_621: usize = 3;
+const IN_621: usize = 3;
+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_617], 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];
@@ -52313,8 +52413,8 @@ fn aiur_fn_617(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_617] = [__v_6];
-        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_621] = [__v_6];
+        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -52325,28 +52425,28 @@ fn aiur_fn_617(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_617] = [__v_9];
-            record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_621] = [__v_9];
+            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __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 __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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_7, __v_10]; 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_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 __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_8, __v_5, __v_2]; 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_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 __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_617] = [__v_12];
-                record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_621] = [__v_12];
+                record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_617] = [__v_12];
-                record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_621] = [__v_12];
+                record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -52363,15 +52463,15 @@ fn aiur_fn_617(
   })
 }
 
-const INPUT_SIZE_618: usize = 4;
-const IN_618: usize = 4;
-const OUT_618: usize = 1;
-fn aiur_fn_618(
-  inp: [G; IN_618],
+const INPUT_SIZE_622: usize = 4;
+const IN_622: usize = 4;
+const OUT_622: usize = 1;
+fn aiur_fn_622(
+  inp: [G; IN_622],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_618], 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];
@@ -52380,8 +52480,8 @@ fn aiur_fn_618(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_618] = [__v_0];
-        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_622] = [__v_0];
+        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52397,25 +52497,25 @@ fn aiur_fn_618(
         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_618] = { let __args: [G; IN_618] = [__v_14, __v_1, __v_2, __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_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 __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_618] = [__v_17];
-        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_622] = [__v_17];
+        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_619: usize = 6;
-const IN_619: usize = 6;
-const OUT_619: usize = 1;
-fn aiur_fn_619(
-  inp: [G; IN_619],
+const INPUT_SIZE_623: usize = 6;
+const IN_623: usize = 6;
+const OUT_623: usize = 1;
+fn aiur_fn_623(
+  inp: [G; IN_623],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_619], 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];
@@ -52426,32 +52526,32 @@ fn aiur_fn_619(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_619] = [__v_7];
-        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_623] = [__v_7];
+        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+        let __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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_619] = [__v_6];
-        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_623] = [__v_6];
+        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_620: usize = 2;
-const IN_620: usize = 2;
-const OUT_620: usize = 1;
-fn aiur_fn_620(
-  inp: [G; IN_620],
+const INPUT_SIZE_624: usize = 2;
+const IN_624: usize = 2;
+const OUT_624: usize = 1;
+fn aiur_fn_624(
+  inp: [G; IN_624],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_620], 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];
@@ -52467,12 +52567,12 @@ fn aiur_fn_620(
         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_620] = [__v_10];
-        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_624] = [__v_10];
+        record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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_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];
@@ -52489,21 +52589,21 @@ fn aiur_fn_620(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_7, __v_1]; 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_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 __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_620] = [__v_22];
-            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_624] = [__v_22];
+            record.function_queries[624].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_620] = { let __args: [G; IN_620] = [__v_7, __v_1]; 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_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 __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_620] = [__v_23];
-            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_624] = [__v_23];
+            record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52515,15 +52615,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_625: usize = 3;
+const IN_625: usize = 3;
+const OUT_625: usize = 1;
+fn aiur_fn_625(
+  inp: [G; IN_625],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_621], 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];
@@ -52561,28 +52661,28 @@ fn aiur_fn_621(
     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_126] = { let __args: [G; IN_126] = [__v_1, __v_35]; 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_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 __v_36: G = __r_arr[0];
     match __v_36.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_621] = [__v_0];
-        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_625] = [__v_0];
+        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_37: G = G::from_u64(0);
-        let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1, __v_2, __v_2, __v_37]; 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_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 __v_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         match __v_38.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_621] = [__v_39];
-            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_625] = [__v_39];
+            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_621] = [__v_0];
-            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_625] = [__v_0];
+            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52594,20 +52694,20 @@ fn aiur_fn_621(
   })
 }
 
-const INPUT_SIZE_622: usize = 3;
-const IN_622: usize = 3;
-const OUT_622: usize = 1;
-fn aiur_fn_622(
-  inp: [G; IN_622],
+const INPUT_SIZE_626: usize = 3;
+const IN_626: usize = 3;
+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_622], ExecError> {
+) -> Result<[G; OUT_626], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __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_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 __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];
@@ -52618,29 +52718,29 @@ fn aiur_fn_622(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_622] = [__v_9];
-        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_626] = [__v_9];
+        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_622] = [__v_9];
-        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_626] = [__v_9];
+        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_623: usize = 3;
-const IN_623: usize = 3;
-const OUT_623: usize = 1;
-fn aiur_fn_623(
-  inp: [G; IN_623],
+const INPUT_SIZE_627: usize = 3;
+const IN_627: usize = 3;
+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_623], 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];
@@ -52652,25 +52752,25 @@ fn aiur_fn_623(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_623] = [__v_6];
-        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_627] = [__v_6];
+        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1, __v_2]; 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_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 __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_623] = [__v_7];
-            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_627] = [__v_7];
+            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_5, __v_1, __v_2]; 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_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 __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_627] = [__v_7];
+            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -52685,37 +52785,37 @@ fn aiur_fn_623(
   })
 }
 
-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_628: usize = 2;
+const IN_628: usize = 2;
+const OUT_628: usize = 1;
+fn aiur_fn_628(
+  inp: [G; IN_628],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_624], ExecError> {
+) -> Result<[G; OUT_628], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1]; 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_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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_2, __v_1]; 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_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 __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_624] = [__v_3];
-    record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_628] = [__v_3];
+    record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_625: usize = 4;
-const IN_625: usize = 4;
-const OUT_625: usize = 2;
-fn aiur_fn_625(
-  inp: [G; IN_625],
+const INPUT_SIZE_629: usize = 4;
+const IN_629: usize = 4;
+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_625], ExecError> {
+) -> Result<[G; OUT_629], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52729,8 +52829,8 @@ fn aiur_fn_625(
       1u64 => {
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_625] = [__v_7, __v_8];
-        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_629] = [__v_7, __v_8];
+        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -52748,23 +52848,23 @@ fn aiur_fn_625(
         let __v_17: G = __loaded[10];
         match __v_7.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_17, __v_0]; 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_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 __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_625] = { let __args: [G; IN_625] = [__v_0, __v_6, __v_2, __v_20]; 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_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 __v_21: G = __r_arr[0];
                 let __v_22: G = __r_arr[1];
-                let __ret: [G; OUT_625] = [__v_21, __v_22];
-                record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_629] = [__v_21, __v_22];
+                record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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_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 __v_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_19]; 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_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 __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];
@@ -52780,23 +52880,23 @@ fn aiur_fn_625(
                 let __v_31: G = __loaded[10];
                 match __v_21.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_19, __v_2]; 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_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 __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_625] = { let __args: [G; IN_625] = [__v_0, __v_6, __v_2, __v_34]; 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_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 __v_35: G = __r_arr[0];
                         let __v_36: G = __r_arr[1];
-                        let __ret: [G; OUT_625] = [__v_35, __v_36];
-                        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_629] = [__v_35, __v_36];
+                        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_33: G = G::from_u64(1);
-                        let __ret: [G; OUT_625] = [__v_33, __v_19];
-                        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_629] = [__v_33, __v_19];
+                        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -52804,11 +52904,11 @@ fn aiur_fn_625(
                   _ => {
                     let __v_32: G = G::from_u64(1);
                     let __v_33: G = (__v_3 + __v_32);
-                    let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_6, __v_2, __v_33]; 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_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 __v_34: G = __r_arr[0];
                     let __v_35: G = __r_arr[1];
-                    let __ret: [G; OUT_625] = [__v_34, __v_35];
-                    record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_629] = [__v_34, __v_35];
+                    record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -52821,11 +52921,11 @@ fn aiur_fn_625(
           _ => {
             let __v_18: G = G::from_u64(1);
             let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_6, __v_2, __v_19]; 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_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 __v_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
-            let __ret: [G; OUT_625] = [__v_20, __v_21];
-            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_629] = [__v_20, __v_21];
+            record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -52837,15 +52937,15 @@ fn aiur_fn_625(
   })
 }
 
-const INPUT_SIZE_626: usize = 4;
-const IN_626: usize = 4;
-const OUT_626: usize = 1;
-fn aiur_fn_626(
-  inp: [G; IN_626],
+const INPUT_SIZE_630: usize = 4;
+const IN_630: usize = 4;
+const OUT_630: usize = 1;
+fn aiur_fn_630(
+  inp: [G; IN_630],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_626], ExecError> {
+) -> Result<[G; OUT_630], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52853,8 +52953,8 @@ fn aiur_fn_626(
     let __v_3: G = inp[3];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_626] = [__v_3];
-        record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_630] = [__v_3];
+        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52864,12 +52964,12 @@ fn aiur_fn_626(
         let __v_6: G = __loaded[2];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_626] = [__v_3];
-            record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_630] = [__v_3];
+            record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_5]; 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_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 __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];
@@ -52887,22 +52987,22 @@ fn aiur_fn_626(
               5u64 => {
                 let __v_19: G = G::from_u64(1);
                 let __v_20: G = (__v_1 - __v_19);
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_13]; 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_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 __v_21: G = __r_arr[0];
                 let __v_22: G = (__v_3 + __v_21);
-                let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_6, __v_20, __v_2, __v_22]; 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_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 __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_626] = [__v_23];
-                record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_630] = [__v_23];
+                record.function_queries[630].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_626] = { let __args: [G; IN_626] = [__v_6, __v_20, __v_2, __v_3]; 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_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 __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_626] = [__v_21];
-                record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_630] = [__v_21];
+                record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -52916,20 +53016,20 @@ fn aiur_fn_626(
   })
 }
 
-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_631: usize = 3;
+const IN_631: usize = 3;
+const OUT_631: usize = 1;
+fn aiur_fn_631(
+  inp: [G; IN_631],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_627], ExecError> {
+) -> Result<[G; OUT_631], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __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_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_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];
@@ -52945,33 +53045,33 @@ fn aiur_fn_627(
     let __v_14: G = __loaded[10];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_9, __v_7, __v_1, __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_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 __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_627] = [__v_15];
-        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_631] = [__v_15];
+        record.function_queries[631].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_627] = [__v_17];
-        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_631] = [__v_17];
+        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_628: usize = 4;
-const IN_628: usize = 4;
-const OUT_628: usize = 1;
-fn aiur_fn_628(
-  inp: [G; IN_628],
+const INPUT_SIZE_632: usize = 4;
+const IN_632: usize = 4;
+const OUT_632: usize = 1;
+fn aiur_fn_632(
+  inp: [G; IN_632],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_628], ExecError> {
+) -> Result<[G; OUT_632], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52986,12 +53086,12 @@ fn aiur_fn_628(
         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_628] = [__v_9];
-        record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_632] = [__v_9];
+        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_5]; 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_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 __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];
@@ -53007,24 +53107,24 @@ fn aiur_fn_628(
         let __v_18: G = __loaded[10];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_10, __v_1]; 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_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 __v_19: G = __r_arr[0];
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_19, __v_2, __v_3, __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_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 __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } };
+            let __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 __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_21, __v_22]; 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_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 __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_628] = [__v_23];
-            record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_632] = [__v_23];
+            record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } };
+            let __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 __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_628] = [__v_19];
-            record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_632] = [__v_19];
+            record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -53036,15 +53136,15 @@ fn aiur_fn_628(
   })
 }
 
-const INPUT_SIZE_629: usize = 4;
-const IN_629: usize = 4;
-const OUT_629: usize = 1;
-fn aiur_fn_629(
-  inp: [G; IN_629],
+const INPUT_SIZE_633: usize = 4;
+const IN_633: usize = 4;
+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_629], 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];
@@ -53057,48 +53157,48 @@ fn aiur_fn_629(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_5, __v_1, __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_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 __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_629] = { let __args: [G; IN_629] = [__v_6, __v_1, __v_2, __v_10]; 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_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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_629] = [__v_12];
-        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_633] = [__v_12];
+        record.function_queries[633].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_629] = [__v_10];
-        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_633] = [__v_10];
+        record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-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_634: usize = 4;
+const IN_634: usize = 4;
+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_630], ExecError> {
+) -> Result<[G; OUT_634], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0]; 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_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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; 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_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 __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 };
@@ -53108,19 +53208,19 @@ fn aiur_fn_630(
     let __v_11: G = __loaded[3];
     match __v_8.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_1, __v_9]; 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_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 __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_630] = [__v_15];
-            record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_634] = [__v_15];
+            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_9]; 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_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 __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];
@@ -53136,7 +53236,7 @@ fn aiur_fn_630(
             let __v_24: G = __loaded[10];
             match __v_14.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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() {
@@ -53144,49 +53244,49 @@ fn aiur_fn_630(
                     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_630] = [__v_29];
-                    record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_634] = [__v_29];
+                    record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_7, __v_17]; 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_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 __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_27, __v_1]; 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_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 __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_630] = [__v_31];
-                        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_634] = [__v_31];
+                        record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __v_29: G = __r_arr[0];
                         let __v_30: G = (__v_3 + __v_29);
-                        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_27, __v_30]; 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_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 __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_630] = [__v_34];
-                            record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_634] = [__v_34];
+                            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           1u64 => {
-                            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_27, __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 __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 __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_630] = [__v_37];
-                            record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_634] = [__v_37];
+                            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -53208,8 +53308,8 @@ fn aiur_fn_630(
                 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_630] = [__v_27];
-                record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_634] = [__v_27];
+                record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -53223,23 +53323,23 @@ fn aiur_fn_630(
         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_630] = [__v_14];
-        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_634] = [__v_14];
+        record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_631: usize = 2;
-const IN_631: usize = 2;
-const OUT_631: usize = 1;
-fn aiur_fn_631(
-  inp: [G; IN_631],
+const INPUT_SIZE_635: usize = 2;
+const IN_635: usize = 2;
+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_631], 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];
@@ -53250,26 +53350,26 @@ fn aiur_fn_631(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_631] = [__v_5];
-        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_635] = [__v_5];
+        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __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 __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_631] = [__v_7];
-            record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_635] = [__v_7];
+            record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_1]; 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_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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_631] = [__v_7];
-            record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_635] = [__v_7];
+            record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53284,15 +53384,15 @@ fn aiur_fn_631(
   })
 }
 
-const INPUT_SIZE_632: usize = 2;
-const IN_632: usize = 2;
-const OUT_632: usize = 1;
-fn aiur_fn_632(
-  inp: [G; IN_632],
+const INPUT_SIZE_636: usize = 2;
+const IN_636: usize = 2;
+const OUT_636: usize = 1;
+fn aiur_fn_636(
+  inp: [G; IN_636],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_632], 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];
@@ -53305,20 +53405,20 @@ fn aiur_fn_632(
         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_632] = [__v_7];
-        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_636] = [__v_7];
+        record.function_queries[636].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_400] = { let __args: [G; IN_400] = [__v_3, __v_1, __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_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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_1]; 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_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 __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_632] = [__v_9];
-        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_636] = [__v_9];
+        record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53328,15 +53428,15 @@ fn aiur_fn_632(
   })
 }
 
-const INPUT_SIZE_633: usize = 6;
-const IN_633: usize = 6;
-const OUT_633: usize = 1;
-fn aiur_fn_633(
-  inp: [G; IN_633],
+const INPUT_SIZE_637: usize = 6;
+const IN_637: usize = 6;
+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_633], 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];
@@ -53346,15 +53446,15 @@ fn aiur_fn_633(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_633] = [__v_0];
-        record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_637] = [__v_0];
+        record.function_queries[637].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_424] = { let __args: [G; IN_424] = [__v_0, __v_8, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+        let __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 __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];
@@ -53363,19 +53463,19 @@ fn aiur_fn_633(
         let __v_13: G = __loaded[3];
         match __v_10.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_3]; 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_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 __v_14: G = __r_arr[0];
             let __v_15: G = G::from_u64(0);
-            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_12, __v_14, __v_15]; 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_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 __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_633] = { let __args: [G; IN_633] = [__v_16, __v_18, __v_2, __v_20, __v_4, __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 __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 __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_633] = [__v_21];
-            record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_637] = [__v_21];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53387,15 +53487,15 @@ fn aiur_fn_633(
   })
 }
 
-const INPUT_SIZE_634: usize = 6;
-const IN_634: usize = 6;
-const OUT_634: usize = 1;
-fn aiur_fn_634(
-  inp: [G; IN_634],
+const INPUT_SIZE_638: usize = 6;
+const IN_638: usize = 6;
+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_634], 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];
@@ -53403,26 +53503,26 @@ fn aiur_fn_634(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+    let __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 __v_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_6, __v_1, __v_2, __v_7, __v_4, __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 __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 __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_634] = [__v_8];
-    record.function_queries[634].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);
   })
 }
 
-const INPUT_SIZE_635: usize = 21;
-const IN_635: usize = 21;
-const OUT_635: usize = 1;
-fn aiur_fn_635(
-  inp: [G; IN_635],
+const INPUT_SIZE_639: usize = 21;
+const IN_639: usize = 21;
+const OUT_639: usize = 1;
+fn aiur_fn_639(
+  inp: [G; IN_639],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_635], 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];
@@ -53454,12 +53554,12 @@ fn aiur_fn_635(
         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_635] = [__v_26];
-        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_639] = [__v_26];
+        record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_18, __v_22]; 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_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 __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];
@@ -53475,16 +53575,16 @@ fn aiur_fn_635(
         let __v_35: G = __loaded[10];
         match __v_25.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__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[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_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 __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_635] = { let __args: [G; IN_635] = [__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[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_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 __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_635] = [__v_41];
-            record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_639] = [__v_41];
+            record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53499,15 +53599,15 @@ fn aiur_fn_635(
   })
 }
 
-const INPUT_SIZE_636: usize = 11;
-const IN_636: usize = 11;
-const OUT_636: usize = 1;
-fn aiur_fn_636(
-  inp: [G; IN_636],
+const INPUT_SIZE_640: usize = 11;
+const IN_640: usize = 11;
+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_636], 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];
@@ -53529,36 +53629,36 @@ fn aiur_fn_636(
         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_636] = [__v_16];
-        record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_640] = [__v_16];
+        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __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_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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_14]; 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_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 __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_777] = { let __args: [G; IN_777] = [__v_2, __v_12]; 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_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 __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_396] = { let __args: [G; IN_396] = [__v_18, __v_20, __v_21]; 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_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 __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_22, __v_7, __v_8, __v_9]; 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_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 __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_23]; 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_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 __v_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_24]; 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_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 __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_26, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_25, __v_27, __v_8, __v_9]; 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_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 __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_24]; 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_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 __v_29: G = __r_arr[0];
         let __v_30: G = (__v_17 + __v_29);
         let __v_31: G = G::from_u64(1);
@@ -53569,35 +53669,35 @@ fn aiur_fn_636(
         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_198] = { let __args: [G; IN_198] = [__v_28]; 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_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 __v_39: G = __r_arr[0];
         let __v_40: G = __r_arr[1];
-        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_40, __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_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 __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_410] = { let __args: [G; IN_410] = [__v_44, __v_41]; 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_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 __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_540] = { let __args: [G; IN_540] = [__v_48, __v_29, __v_49]; 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_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 __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_541] = { let __args: [G; IN_541] = [__v_53, __v_24]; 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_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 __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_636] = { let __args: [G; IN_636] = [__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[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_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 __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_636] = [__v_59];
-        record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_640] = [__v_59];
+        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53607,15 +53707,15 @@ fn aiur_fn_636(
   })
 }
 
-const INPUT_SIZE_637: usize = 7;
-const IN_637: usize = 7;
-const OUT_637: usize = 0;
-fn aiur_fn_637(
-  inp: [G; IN_637],
+const INPUT_SIZE_641: usize = 7;
+const IN_641: usize = 7;
+const OUT_641: usize = 0;
+fn aiur_fn_641(
+  inp: [G; IN_641],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_637], 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];
@@ -53657,19 +53757,19 @@ fn aiur_fn_637(
     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_126] = { let __args: [G; IN_126] = [__v_4, __v_39]; 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_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 __v_40: G = __r_arr[0];
     match __v_40.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_637] = [];
-        record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_641] = [];
+        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_41: G = G::from_u64(0);
-        let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__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[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 __ret: [G; OUT_637] = [];
-        record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -53679,15 +53779,15 @@ fn aiur_fn_637(
   })
 }
 
-const INPUT_SIZE_638: usize = 9;
-const IN_638: usize = 9;
-const OUT_638: usize = 0;
-fn aiur_fn_638(
-  inp: [G; IN_638],
+const INPUT_SIZE_642: usize = 9;
+const IN_642: usize = 9;
+const OUT_642: usize = 0;
+fn aiur_fn_642(
+  inp: [G; IN_642],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_638], 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];
@@ -53704,8 +53804,8 @@ fn aiur_fn_638(
     let __v_11: G = __loaded[2];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_638] = [];
-        record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_642] = [];
+        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -53723,7 +53823,7 @@ fn aiur_fn_638(
         let __v_22: G = __loaded[10];
         match __v_12.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_4]; 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_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 __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));
@@ -53732,23 +53832,23 @@ fn aiur_fn_638(
             let __v_28: G = (__v_23 * __v_27);
             match __v_28.as_canonical_u64() {
               1u64 => {
-                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_639] = { let __args: [G; IN_639] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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_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 __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_504] = { let __args: [G; IN_504] = [__v_1, __v_29, __v_32, __v_6, __v_7]; 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 __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 __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_504] = { let __args: [G; IN_504] = [__v_14, __v_34, __v_37, __v_6, __v_7]; 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 __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 __v_38: G = __r_arr[0];
-                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_33, __v_38]; 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)? } };
+                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 __v_39: G = __r_arr[0];
                 let __v_40: G = G::from_u64(1);
                 if (__v_39 != __v_40) {
@@ -53756,17 +53856,17 @@ fn aiur_fn_638(
                 }
                 let __v_41: G = G::from_u64(1);
                 let __v_42: G = (__v_8 + __v_41);
-                let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__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[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 __ret: [G; OUT_638] = [];
-                record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 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_638] = { let __args: [G; IN_638] = [__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[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 __ret: [G; OUT_638] = [];
-                record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -53777,9 +53877,9 @@ fn aiur_fn_638(
           _ => {
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__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[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 __ret: [G; OUT_638] = [];
-            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -53791,15 +53891,15 @@ fn aiur_fn_638(
   })
 }
 
-const INPUT_SIZE_639: usize = 5;
-const IN_639: usize = 5;
-const OUT_639: usize = 0;
-fn aiur_fn_639(
-  inp: [G; IN_639],
+const INPUT_SIZE_643: usize = 5;
+const IN_643: usize = 5;
+const OUT_643: usize = 0;
+fn aiur_fn_643(
+  inp: [G; IN_643],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_639], 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];
@@ -53809,22 +53909,22 @@ fn aiur_fn_639(
     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_640] = { let __args: [G; IN_640] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; 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 __ret: [G; OUT_639] = [];
-    record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_640: usize = 6;
-const IN_640: usize = 6;
-const OUT_640: usize = 0;
-fn aiur_fn_640(
-  inp: [G; IN_640],
+const INPUT_SIZE_644: usize = 6;
+const IN_644: usize = 6;
+const OUT_644: usize = 0;
+fn aiur_fn_644(
+  inp: [G; IN_644],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_640], 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];
@@ -53834,8 +53934,8 @@ fn aiur_fn_640(
     let __v_5: G = inp[5];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_640] = [];
-        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53853,19 +53953,19 @@ fn aiur_fn_640(
             let __v_13: G = __loaded[3];
             match __v_10.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_7, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
+                let __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 __v_14: G = __r_arr[0];
-                let __v_15: G = G::from_u64(1);
-                if (__v_14 != __v_15) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+                let __v_15: G = G::from_u64(0);
+                let __v_16: G = { let __values: [G; 3] = [__v_15, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_17: G = G::from_u64(1);
+                if (__v_14 != __v_17) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
                 }
-                let __v_16: G = G::from_u64(0);
-                let __v_17: G = { let __values: [G; 3] = [__v_16, __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_18: G = G::from_u64(1);
                 let __v_19: G = (__v_2 - __v_18);
-                let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_12, __v_19, __v_17, __v_4, __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 __ret: [G; OUT_640] = [];
-                record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -53882,15 +53982,15 @@ fn aiur_fn_640(
   })
 }
 
-const INPUT_SIZE_641: usize = 2;
-const IN_641: usize = 2;
-const OUT_641: usize = 1;
-fn aiur_fn_641(
-  inp: [G; IN_641],
+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_641], 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];
@@ -53898,8 +53998,8 @@ fn aiur_fn_641(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_641] = [__v_3];
-        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_645] = [__v_3];
+        record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -53907,14 +54007,14 @@ fn aiur_fn_641(
         match __v_3.as_canonical_u64() {
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_641] = [__v_4];
-            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_645] = [__v_4];
+            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_641] = [__v_4];
-            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_645] = [__v_4];
+            record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -53926,132 +54026,132 @@ fn aiur_fn_641(
   })
 }
 
-const INPUT_SIZE_642: usize = 2;
-const IN_642: usize = 2;
-const OUT_642: usize = 1;
-fn aiur_fn_642(
-  inp: [G; IN_642],
+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_642], 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];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_642] = [__v_1];
-        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_646] = [__v_1];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_642] = [__v_0];
-        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_646] = [__v_0];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_643: usize = 0;
-const IN_643: usize = 0;
-const OUT_643: usize = 2;
-fn aiur_fn_643(
-  inp: [G; IN_643],
+const INPUT_SIZE_647: usize = 0;
+const IN_647: usize = 0;
+const OUT_647: usize = 2;
+fn aiur_fn_647(
+  inp: [G; IN_647],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_643], ExecError> {
+) -> Result<[G; OUT_647], 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_643] = [__v_0, __v_1];
-    record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_644: usize = 0;
-const IN_644: usize = 0;
-const OUT_644: usize = 2;
-fn aiur_fn_644(
-  inp: [G; IN_644],
+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_644], ExecError> {
+) -> 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_644] = [__v_0, __v_1];
-    record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_648] = [__v_0, __v_1];
+    record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_645: usize = 0;
-const IN_645: usize = 0;
-const OUT_645: usize = 2;
-fn aiur_fn_645(
-  inp: [G; IN_645],
+const INPUT_SIZE_649: usize = 0;
+const IN_649: usize = 0;
+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_645], ExecError> {
+) -> Result<[G; OUT_649], 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_645] = [__v_0, __v_1];
-    record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_649] = [__v_0, __v_1];
+    record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_646: usize = 0;
-const IN_646: usize = 0;
-const OUT_646: usize = 2;
-fn aiur_fn_646(
-  inp: [G; IN_646],
+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_646], ExecError> {
+) -> 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_646] = [__v_0, __v_1];
-    record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_647: usize = 0;
-const IN_647: usize = 0;
-const OUT_647: usize = 2;
-fn aiur_fn_647(
-  inp: [G; IN_647],
+const INPUT_SIZE_651: usize = 0;
+const IN_651: usize = 0;
+const OUT_651: usize = 2;
+fn aiur_fn_651(
+  inp: [G; IN_651],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_647], ExecError> {
+) -> Result<[G; OUT_651], 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_647] = [__v_0, __v_1];
-    record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_651] = [__v_0, __v_1];
+    record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_648: usize = 4;
-const IN_648: usize = 4;
-const OUT_648: usize = 2;
-fn aiur_fn_648(
-  inp: [G; IN_648],
+const INPUT_SIZE_652: usize = 4;
+const IN_652: usize = 4;
+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_648], 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];
@@ -54060,46 +54160,46 @@ fn aiur_fn_648(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_4: G = (__v_1 * __v_3);
-        let __ret: [G; OUT_648] = [__v_2, __v_4];
-        record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_652] = [__v_2, __v_4];
+        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_648] = [__v_0, __v_1];
-        record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_652] = [__v_0, __v_1];
+        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_649: usize = 1;
-const IN_649: usize = 1;
-const OUT_649: usize = 2;
-fn aiur_fn_649(
-  inp: [G; IN_649],
+const INPUT_SIZE_653: usize = 1;
+const IN_653: usize = 1;
+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_649], ExecError> {
+) -> Result<[G; OUT_653], 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_649] = [__v_0, __v_1];
-    record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_653] = [__v_0, __v_1];
+    record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_650: usize = 2;
-const IN_650: usize = 2;
-const OUT_650: usize = 1;
-fn aiur_fn_650(
-  inp: [G; IN_650],
+const INPUT_SIZE_654: usize = 2;
+const IN_654: usize = 2;
+const OUT_654: usize = 1;
+fn aiur_fn_654(
+  inp: [G; IN_654],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_650], 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];
@@ -54111,8 +54211,8 @@ fn aiur_fn_650(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_650] = [__v_6];
-        record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_654] = [__v_6];
+        record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -54121,15 +54221,15 @@ fn aiur_fn_650(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_7 + __v_4);
-            let __ret: [G; OUT_650] = [__v_8];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_8];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_650] = [__v_7];
-            record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_654] = [__v_7];
+            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54141,15 +54241,15 @@ fn aiur_fn_650(
   })
 }
 
-const INPUT_SIZE_651: usize = 2;
-const IN_651: usize = 2;
-const OUT_651: usize = 1;
-fn aiur_fn_651(
-  inp: [G; IN_651],
+const INPUT_SIZE_655: usize = 2;
+const IN_655: usize = 2;
+const OUT_655: usize = 1;
+fn aiur_fn_655(
+  inp: [G; IN_655],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_651], 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];
@@ -54219,51 +54319,51 @@ fn aiur_fn_651(
     let __v_63: G = __loaded[29];
     let __v_64: G = __loaded[30];
     let __v_65: G = __loaded[31];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_66: G = __r_arr[0];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_72: G = __r_arr[0];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__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[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_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 __v_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_72, __v_73]; 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 __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 __v_74: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_71, __v_74]; 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 __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 __v_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_70, __v_75]; 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 __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 __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_69, __v_76]; 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 __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 __v_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_68, __v_77]; 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 __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 __v_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_67, __v_78]; 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 __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 __v_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_66, __v_79]; 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 __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 __v_80: G = __r_arr[0];
-    let __ret: [G; OUT_651] = [__v_80];
-    record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_655] = [__v_80];
+    record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_652: usize = 8;
-const IN_652: usize = 8;
-const OUT_652: usize = 1;
-fn aiur_fn_652(
-  inp: [G; IN_652],
+const INPUT_SIZE_656: usize = 8;
+const IN_656: usize = 8;
+const OUT_656: usize = 1;
+fn aiur_fn_656(
+  inp: [G; IN_656],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_652], 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];
@@ -54291,23 +54391,23 @@ fn aiur_fn_652(
     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_641] = { let __args: [G; IN_641] = [__v_16, __v_25]; 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_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 __v_26: G = __r_arr[0];
-    let __ret: [G; OUT_652] = [__v_26];
-    record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_656] = [__v_26];
+    record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_653: usize = 4;
-const IN_653: usize = 4;
-const OUT_653: usize = 2;
-fn aiur_fn_653(
-  inp: [G; IN_653],
+const INPUT_SIZE_657: usize = 4;
+const IN_657: usize = 4;
+const OUT_657: usize = 2;
+fn aiur_fn_657(
+  inp: [G; IN_657],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_653], 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];
@@ -54316,41 +54416,41 @@ fn aiur_fn_653(
     let __v_4: G = (__v_0 - __v_1);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_653] = [__v_5, __v_6];
-        record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_657] = [__v_5, __v_6];
+        record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __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_777] = { let __args: [G; IN_777] = [__v_3, __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_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 __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_1]; 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_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 __v_8: G = __r_arr[0];
-                let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_7, __v_8]; 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_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 __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_9]; 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_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 __v_10: G = __r_arr[0];
                 let __v_11: G = __r_arr[1];
-                let __ret: [G; OUT_653] = [__v_10, __v_11];
-                record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_657] = [__v_10, __v_11];
+                record.function_queries[657].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_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 __v_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_653] = [__v_7, __v_8];
-                record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_657] = [__v_7, __v_8];
+                record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -54358,19 +54458,19 @@ fn aiur_fn_653(
           _ => {
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_653] = [__v_7, __v_8];
-                record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_657] = [__v_7, __v_8];
+                record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_6]; 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_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 __v_7: G = __r_arr[0];
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_653] = [__v_7, __v_8];
-                record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_657] = [__v_7, __v_8];
+                record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -54381,15 +54481,15 @@ fn aiur_fn_653(
   })
 }
 
-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_658: usize = 2;
+const IN_658: usize = 2;
+const OUT_658: usize = 1;
+fn aiur_fn_658(
+  inp: [G; IN_658],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_654], 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];
@@ -54406,14 +54506,14 @@ fn aiur_fn_654(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54426,21 +54526,21 @@ fn aiur_fn_654(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54453,31 +54553,31 @@ fn aiur_fn_654(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_7]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_654] = [__v_10];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_10];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54490,37 +54590,37 @@ fn aiur_fn_654(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_7]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_654] = [__v_10];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_10];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -54535,16 +54635,16 @@ fn aiur_fn_654(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_3, __v_6]; 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_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 __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_8];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_658] = [__v_8];
+            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54556,15 +54656,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_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_655], 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];
@@ -54581,14 +54681,14 @@ fn aiur_fn_655(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_655] = [__v_8];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_659] = [__v_8];
+            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_655] = [__v_8];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_659] = [__v_8];
+            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54601,19 +54701,19 @@ fn aiur_fn_655(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_655] = [__v_8];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_659] = [__v_8];
+            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_4, __v_7]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_655] = [__v_10];
-            record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_659] = [__v_10];
+            record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -54628,38 +54728,38 @@ fn aiur_fn_655(
   })
 }
 
-const INPUT_SIZE_656: usize = 2;
-const IN_656: usize = 2;
-const OUT_656: usize = 2;
-fn aiur_fn_656(
-  inp: [G; IN_656],
+const INPUT_SIZE_660: usize = 2;
+const IN_660: usize = 2;
+const OUT_660: usize = 2;
+fn aiur_fn_660(
+  inp: [G; IN_660],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_656], 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];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_1]; 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_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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_656] = [__v_3, __v_4];
-    record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_660] = [__v_3, __v_4];
+    record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_657: usize = 2;
-const IN_657: usize = 2;
-const OUT_657: usize = 1;
-fn aiur_fn_657(
-  inp: [G; IN_657],
+const INPUT_SIZE_661: usize = 2;
+const IN_661: usize = 2;
+const OUT_661: usize = 1;
+fn aiur_fn_661(
+  inp: [G; IN_661],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_657], 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];
@@ -54667,8 +54767,8 @@ fn aiur_fn_657(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_657] = [__v_3];
-        record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_661] = [__v_3];
+        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -54682,25 +54782,25 @@ fn aiur_fn_657(
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
-        let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__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[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_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 __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_657] = [__v_11];
-        record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_661] = [__v_11];
+        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_658: usize = 8;
-const IN_658: usize = 8;
-const OUT_658: usize = 1;
-fn aiur_fn_658(
-  inp: [G; IN_658],
+const INPUT_SIZE_662: usize = 8;
+const IN_662: usize = 8;
+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_658], 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];
@@ -54714,16 +54814,16 @@ fn aiur_fn_658(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_5]; 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_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 __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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54732,21 +54832,21 @@ fn aiur_fn_658(
         match __v_4.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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __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 __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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54755,31 +54855,31 @@ fn aiur_fn_658(
         match __v_4.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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_2, __v_6]; 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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_5]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __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_662] = [__v_10];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54788,37 +54888,37 @@ fn aiur_fn_658(
         match __v_4.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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_2, __v_6]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __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_662] = [__v_10];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54827,43 +54927,43 @@ fn aiur_fn_658(
         match __v_4.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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_2, __v_6]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __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_662] = [__v_10];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54872,49 +54972,49 @@ fn aiur_fn_658(
         match __v_4.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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_2, __v_6]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __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_662] = [__v_10];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54923,59 +55023,59 @@ fn aiur_fn_658(
         match __v_4.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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
             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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
             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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
             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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_2, __v_6]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_3, __v_7]; 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_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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+            let __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 __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_11]; 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 __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 __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_658] = [__v_12];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_12];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -54984,21 +55084,21 @@ fn aiur_fn_658(
         match __v_4.as_canonical_u64() {
           8u64 => {
             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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __v_2, __v_5, __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_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 __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_662] = [__v_8];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55006,24 +55106,24 @@ fn aiur_fn_658(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_5]; 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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_2, __v_6]; 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_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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_3, __v_7]; 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_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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+            let __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 __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_11]; 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 __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 __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_658] = [__v_12];
-            record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_662] = [__v_12];
+            record.function_queries[662].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_662] = [__v_8];
+            record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55035,15 +55135,15 @@ fn aiur_fn_658(
   })
 }
 
-const INPUT_SIZE_659: usize = 4;
-const IN_659: usize = 4;
-const OUT_659: usize = 2;
-fn aiur_fn_659(
-  inp: [G; IN_659],
+const INPUT_SIZE_663: usize = 4;
+const IN_663: usize = 4;
+const OUT_663: usize = 2;
+fn aiur_fn_663(
+  inp: [G; IN_663],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_659], ExecError> {
+) -> Result<[G; OUT_663], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55052,11 +55152,11 @@ fn aiur_fn_659(
     let __v_4: G = (__v_0 - __v_1);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_659] = [__v_5, __v_6];
-        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_5, __v_6];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -55070,26 +55170,26 @@ fn aiur_fn_659(
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
         let __v_12: G = __loaded[3];
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__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[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_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 __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_659] = [__v_13, __v_14];
-        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [__v_13, __v_14];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_660: usize = 10;
-const IN_660: usize = 10;
-const OUT_660: usize = 2;
-fn aiur_fn_660(
-  inp: [G; IN_660],
+const INPUT_SIZE_664: usize = 10;
+const IN_664: usize = 10;
+const OUT_664: usize = 2;
+fn aiur_fn_664(
+  inp: [G; IN_664],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_660], ExecError> {
+) -> Result<[G; OUT_664], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55105,21 +55205,21 @@ fn aiur_fn_660(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_5]; 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_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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_11, __v_12];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_11, __v_12];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55127,29 +55227,29 @@ fn aiur_fn_660(
       1u64 => {
         match __v_4.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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_11, __v_12];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_11, __v_12];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55157,41 +55257,41 @@ fn aiur_fn_660(
       2u64 => {
         match __v_4.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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_2, __v_6]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_1, __v_5, __v_8, __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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_11, __v_12, __v_13]; 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 __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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_14, __v_15];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_14, __v_15];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55199,49 +55299,49 @@ fn aiur_fn_660(
       3u64 => {
         match __v_4.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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_5, __v_8, __v_9]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_6, __v_8, __v_9]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_11, __v_12, __v_13]; 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 __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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_14, __v_15];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_14, __v_15];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55249,57 +55349,57 @@ fn aiur_fn_660(
       4u64 => {
         match __v_4.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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_5, __v_8, __v_9]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_6, __v_8, __v_9]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_11, __v_12, __v_13]; 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 __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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_14, __v_15];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_14, __v_15];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55307,65 +55407,65 @@ fn aiur_fn_660(
       5u64 => {
         match __v_4.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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_5, __v_8, __v_9]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_6, __v_8, __v_9]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_11, __v_12, __v_13]; 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 __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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_14, __v_15];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_14, __v_15];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55373,79 +55473,79 @@ fn aiur_fn_660(
       6u64 => {
         match __v_4.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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
-            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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_1, __v_5, __v_8, __v_9]; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_6, __v_8, __v_9]; 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_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 __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3, __v_7, __v_8, __v_9]; 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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_12, __v_13, __v_14, __v_15]; 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 __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 __v_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_11, __v_16, __v_17]; 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 __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 __v_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_18, __v_19];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_18, __v_19];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55453,29 +55553,29 @@ fn aiur_fn_660(
       7u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __v_2, __v_5, __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_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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_10]; 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_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 __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_11, __v_12];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_11, __v_12];
+            record.function_queries[664].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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55483,33 +55583,33 @@ fn aiur_fn_660(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_1, __v_5, __v_8, __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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_2, __v_6]; 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_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 __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12]; 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_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 __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3, __v_7, __v_8, __v_9]; 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_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 __v_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_13, __v_14, __v_15, __v_16]; 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 __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 __v_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_11, __v_17, __v_18]; 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 __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 __v_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_19, __v_20];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_19, __v_20];
+            record.function_queries[664].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_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 __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_660] = [__v_10, __v_11];
-            record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_664] = [__v_10, __v_11];
+            record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55521,15 +55621,15 @@ fn aiur_fn_660(
   })
 }
 
-const INPUT_SIZE_661: usize = 4;
-const IN_661: usize = 4;
-const OUT_661: usize = 1;
-fn aiur_fn_661(
-  inp: [G; IN_661],
+const INPUT_SIZE_665: usize = 4;
+const IN_665: usize = 4;
+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_661], 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];
@@ -55539,16 +55639,16 @@ fn aiur_fn_661(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_661] = [__v_4];
-            record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_4];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_661] = [__v_4];
-            record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_4];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55560,15 +55660,15 @@ fn aiur_fn_661(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_661] = [__v_4];
-            record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_4];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_3]; 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_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 __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_661] = [__v_4];
-            record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_665] = [__v_4];
+            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55583,54 +55683,54 @@ fn aiur_fn_661(
   })
 }
 
-const INPUT_SIZE_662: usize = 2;
-const IN_662: usize = 2;
-const OUT_662: usize = 1;
-fn aiur_fn_662(
-  inp: [G; IN_662],
+const INPUT_SIZE_666: usize = 2;
+const IN_666: usize = 2;
+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_662], 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];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; 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_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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_3: G = __r_arr[0];
-    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_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 __v_4: 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_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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_5]; 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_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 __v_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __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 __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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_662] = [__v_7];
-        record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_666] = [__v_7];
+        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_662] = [__v_6];
-        record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_666] = [__v_6];
+        record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_663: usize = 2;
-const IN_663: usize = 2;
-const OUT_663: usize = 1;
-fn aiur_fn_663(
-  inp: [G; IN_663],
+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_663], 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];
@@ -55648,8 +55748,8 @@ fn aiur_fn_663(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_663] = [__v_12];
-        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_667] = [__v_12];
+        record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -55666,14 +55766,14 @@ fn aiur_fn_663(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_11, __v_21]; 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_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 __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__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[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_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 __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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_663] = [__v_24];
-            record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_667] = [__v_24];
+            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55688,15 +55788,15 @@ fn aiur_fn_663(
   })
 }
 
-const INPUT_SIZE_664: usize = 16;
-const IN_664: usize = 16;
-const OUT_664: usize = 1;
-fn aiur_fn_664(
-  inp: [G; IN_664],
+const INPUT_SIZE_668: usize = 16;
+const IN_668: usize = 16;
+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_664], 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];
@@ -55714,51 +55814,51 @@ fn aiur_fn_664(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_15]; 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_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 __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_14]; 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_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 __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __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_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 __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_12]; 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_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 __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_3, __v_11]; 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_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 __v_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_2, __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 __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 __v_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_9]; 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_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 __v_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+    let __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 __v_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_21, __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 __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 __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_20, __v_25]; 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 __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 __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_19, __v_26]; 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 __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 __v_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_18, __v_27]; 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 __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 __v_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_17, __v_28]; 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 __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 __v_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_16, __v_29]; 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 __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 __v_30: G = __r_arr[0];
-    let __ret: [G; OUT_664] = [__v_30];
-    record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_668] = [__v_30];
+    record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_665: usize = 2;
-const IN_665: usize = 2;
-const OUT_665: usize = 1;
-fn aiur_fn_665(
-  inp: [G; IN_665],
+const INPUT_SIZE_669: usize = 2;
+const IN_669: usize = 2;
+const OUT_669: usize = 1;
+fn aiur_fn_669(
+  inp: [G; IN_669],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_665], 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];
@@ -55775,14 +55875,14 @@ fn aiur_fn_665(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_8];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_8];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55795,19 +55895,19 @@ fn aiur_fn_665(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_8];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_3, __v_6]; 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_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 __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
+            let __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 __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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 __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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_10];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_669] = [__v_10];
+            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55822,15 +55922,15 @@ fn aiur_fn_665(
   })
 }
 
-const INPUT_SIZE_666: usize = 6;
-const IN_666: usize = 6;
-const OUT_666: usize = 1;
-fn aiur_fn_666(
-  inp: [G; IN_666],
+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_666], 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];
@@ -55842,14 +55942,14 @@ fn aiur_fn_666(
       _ => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_4]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_5]; 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_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_642] = { let __args: [G; IN_642] = [__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 __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_666] = [__v_8];
-            record.function_queries[666].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);
           },
         }
@@ -55858,15 +55958,15 @@ fn aiur_fn_666(
   })
 }
 
-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_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_667], 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];
@@ -55887,14 +55987,14 @@ fn aiur_fn_667(
         match __v_7.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_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_667] = [__v_12];
-            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_671] = [__v_12];
+            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55909,19 +56009,19 @@ fn aiur_fn_667(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(2);
-            let __ret: [G; OUT_667] = [__v_12];
-            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_666] = { let __args: [G; IN_666] = [__v_3, __v_4, __v_5, __v_8, __v_9, __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 __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_667] = { let __args: [G; IN_667] = [__v_6, __v_11]; 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_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_642] = { let __args: [G; IN_642] = [__v_12, __v_13]; 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 __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_667] = [__v_14];
-            record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_671] = [__v_14];
+            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -55936,15 +56036,15 @@ fn aiur_fn_667(
   })
 }
 
-const INPUT_SIZE_668: usize = 8;
-const IN_668: usize = 8;
-const OUT_668: usize = 2;
-fn aiur_fn_668(
-  inp: [G; IN_668],
+const INPUT_SIZE_672: usize = 8;
+const IN_672: usize = 8;
+const OUT_672: usize = 2;
+fn aiur_fn_672(
+  inp: [G; IN_672],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_668], 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];
@@ -55958,19 +56058,19 @@ fn aiur_fn_668(
       _ => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_4]; 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_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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_8]; 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_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 __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_5, __v_6, __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_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 __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_9, __v_10, __v_11, __v_12]; 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 __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 __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_668] = [__v_13, __v_14];
-            record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_672] = [__v_13, __v_14];
+            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55979,15 +56079,15 @@ fn aiur_fn_668(
   })
 }
 
-const INPUT_SIZE_669: usize = 4;
-const IN_669: usize = 4;
-const OUT_669: usize = 2;
-fn aiur_fn_669(
-  inp: [G; IN_669],
+const INPUT_SIZE_673: usize = 4;
+const IN_673: usize = 4;
+const OUT_673: usize = 2;
+fn aiur_fn_673(
+  inp: [G; IN_673],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_669], 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];
@@ -56009,19 +56109,19 @@ fn aiur_fn_669(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_669] = [__v_14, __v_15];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_673] = [__v_14, __v_15];
+            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = []; 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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_669] = [__v_14, __v_15];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_673] = [__v_14, __v_15];
+            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -56035,25 +56135,25 @@ fn aiur_fn_669(
         let __v_13: G = __loaded[4];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_669] = [__v_14, __v_15];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_673] = [__v_14, __v_15];
+            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__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[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_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 __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_8, __v_13, __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 __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 __v_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_14, __v_15, __v_16, __v_17]; 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 __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 __v_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_669] = [__v_18, __v_19];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_673] = [__v_18, __v_19];
+            record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56068,15 +56168,15 @@ fn aiur_fn_669(
   })
 }
 
-const INPUT_SIZE_670: usize = 11;
-const IN_670: usize = 11;
-const OUT_670: usize = 1;
-fn aiur_fn_670(
-  inp: [G; IN_670],
+const INPUT_SIZE_674: usize = 11;
+const IN_674: usize = 11;
+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_670], 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];
@@ -56092,50 +56192,50 @@ fn aiur_fn_670(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_11: G = G::from_u64(1);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_11: G = G::from_u64(2);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_11: G = G::from_u64(3);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_11: G = G::from_u64(5);
-        let __ret: [G; OUT_670] = [__v_11];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_674] = [__v_11];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -56145,15 +56245,15 @@ fn aiur_fn_670(
   })
 }
 
-const INPUT_SIZE_671: usize = 22;
-const IN_671: usize = 22;
-const OUT_671: usize = 1;
-fn aiur_fn_671(
-  inp: [G; IN_671],
+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_671], 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];
@@ -56177,38 +56277,38 @@ fn aiur_fn_671(
     let __v_19: G = inp[19];
     let __v_20: G = inp[20];
     let __v_21: G = inp[21];
-    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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_670] = { let __args: [G; IN_670] = [__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[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 __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_641] = { let __args: [G; IN_641] = [__v_22, __v_23]; 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_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_672] = { let __args: [G; IN_672] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __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[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_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_671] = [__v_25];
-        record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_671] = [__v_24];
-        record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_675] = [__v_24];
+        record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_672: usize = 22;
-const IN_672: usize = 22;
-const OUT_672: usize = 1;
-fn aiur_fn_672(
-  inp: [G; IN_672],
+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_672], 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];
@@ -56236,18 +56336,18 @@ fn aiur_fn_672(
       1u64 => {
         match __v_11.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_657] = { let __args: [G; IN_657] = [__v_3, __v_14]; 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_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_642] = { let __args: [G; IN_642] = [__v_23, __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 __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_642] = { let __args: [G; IN_642] = [__v_22, __v_25]; 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 __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_672] = [__v_26];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_26];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56258,18 +56358,18 @@ fn aiur_fn_672(
       2u64 => {
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_657] = { let __args: [G; IN_657] = [__v_3, __v_14]; 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_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_642] = { let __args: [G; IN_642] = [__v_23, __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 __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_642] = { let __args: [G; IN_642] = [__v_22, __v_25]; 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 __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_672] = [__v_26];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_26];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56280,22 +56380,22 @@ fn aiur_fn_672(
       3u64 => {
         match __v_11.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_657] = { let __args: [G; IN_657] = [__v_3, __v_14]; 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_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_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_642] = { let __args: [G; IN_642] = [__v_24, __v_25]; 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 __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_642] = { let __args: [G; IN_642] = [__v_23, __v_26]; 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 __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_642] = { let __args: [G; IN_642] = [__v_22, __v_27]; 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 __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_672] = [__v_28];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_28];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56306,14 +56406,14 @@ fn aiur_fn_672(
       4u64 => {
         match __v_11.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_642] = { let __args: [G; IN_642] = [__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 __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_672] = [__v_24];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_24];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56324,18 +56424,18 @@ fn aiur_fn_672(
       0u64 => {
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_641] = { let __args: [G; IN_641] = [__v_3, __v_14]; 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_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_642] = { let __args: [G; IN_642] = [__v_23, __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 __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_642] = { let __args: [G; IN_642] = [__v_22, __v_25]; 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 __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_672] = [__v_26];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_26];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56346,34 +56446,34 @@ fn aiur_fn_672(
       5u64 => {
         match __v_11.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_17]; 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_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_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_641] = { let __args: [G; IN_641] = [__v_3, __v_14]; 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_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_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_196] = { let __args: [G; IN_196] = [__v_5]; 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_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_196] = { let __args: [G; IN_196] = [__v_16]; 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_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_641] = { let __args: [G; IN_641] = [__v_26, __v_27]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_642] = { let __args: [G; IN_642] = [__v_28, __v_29]; 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 __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_642] = { let __args: [G; IN_642] = [__v_25, __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 __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_642] = { let __args: [G; IN_642] = [__v_24, __v_31]; 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 __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_642] = { let __args: [G; IN_642] = [__v_23, __v_32]; 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 __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_642] = { let __args: [G; IN_642] = [__v_22, __v_33]; 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 __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_672] = [__v_34];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_34];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56384,26 +56484,26 @@ fn aiur_fn_672(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_641] = { let __args: [G; IN_641] = [__v_5, __v_16]; 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_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_641] = { let __args: [G; IN_641] = [__v_6, __v_17]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_642] = { let __args: [G; IN_642] = [__v_25, __v_26]; 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 __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_642] = { let __args: [G; IN_642] = [__v_24, __v_27]; 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 __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_642] = { let __args: [G; IN_642] = [__v_23, __v_28]; 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 __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_642] = { let __args: [G; IN_642] = [__v_22, __v_29]; 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 __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_672] = [__v_30];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_30];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56414,38 +56514,38 @@ fn aiur_fn_672(
       7u64 => {
         match __v_11.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_641] = { let __args: [G; IN_641] = [__v_3, __v_14]; 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_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_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_641] = { let __args: [G; IN_641] = [__v_5, __v_16]; 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_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_641] = { let __args: [G; IN_641] = [__v_6, __v_17]; 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_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_641] = { let __args: [G; IN_641] = [__v_8, __v_19]; 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_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_657] = { let __args: [G; IN_657] = [__v_2, __v_13]; 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_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_667] = { let __args: [G; IN_667] = [__v_7, __v_18]; 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_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_642] = { let __args: [G; IN_642] = [__v_28, __v_29]; 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 __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_642] = { let __args: [G; IN_642] = [__v_27, __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 __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_642] = { let __args: [G; IN_642] = [__v_26, __v_31]; 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 __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_642] = { let __args: [G; IN_642] = [__v_25, __v_32]; 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 __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_642] = { let __args: [G; IN_642] = [__v_24, __v_33]; 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 __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_642] = { let __args: [G; IN_642] = [__v_23, __v_34]; 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 __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_642] = { let __args: [G; IN_642] = [__v_22, __v_35]; 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 __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_672] = [__v_36];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_676] = [__v_36];
+            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56460,15 +56560,15 @@ fn aiur_fn_672(
   })
 }
 
-const INPUT_SIZE_673: usize = 25;
-const IN_673: usize = 25;
-const OUT_673: usize = 2;
-fn aiur_fn_673(
-  inp: [G; IN_673],
+const INPUT_SIZE_677: usize = 25;
+const IN_677: usize = 25;
+const OUT_677: usize = 2;
+fn aiur_fn_677(
+  inp: [G; IN_677],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_673], 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];
@@ -56495,42 +56595,42 @@ fn aiur_fn_673(
     let __v_22: G = inp[22];
     let __v_23: G = inp[23];
     let __v_24: G = inp[24];
-    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_25, __v_26]; 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_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 __v_27: G = __r_arr[0];
     match __v_27.as_canonical_u64() {
       1u64 => {
-        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, __v_11, __v_12, __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[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_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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_673] = [__v_28, __v_29];
-        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_677] = [__v_28, __v_29];
+        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_27]; 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_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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_673] = [__v_28, __v_29];
-        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_677] = [__v_28, __v_29];
+        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_674: usize = 25;
-const IN_674: usize = 25;
-const OUT_674: usize = 2;
-fn aiur_fn_674(
-  inp: [G; IN_674],
+const INPUT_SIZE_678: usize = 25;
+const IN_678: usize = 25;
+const OUT_678: usize = 2;
+fn aiur_fn_678(
+  inp: [G; IN_678],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_674], 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];
@@ -56561,25 +56661,25 @@ fn aiur_fn_674(
       1u64 => {
         match __v_11.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3, __v_14, __v_22, __v_24]; 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_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 __v_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_28, __v_29, __v_30, __v_31]; 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 __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 __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_32, __v_33]; 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 __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 __v_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_34, __v_35];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_34, __v_35];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56590,25 +56690,25 @@ fn aiur_fn_674(
       2u64 => {
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3, __v_14, __v_22, __v_24]; 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_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 __v_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_28, __v_29, __v_30, __v_31]; 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 __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 __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_32, __v_33]; 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 __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 __v_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_34, __v_35];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_34, __v_35];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56619,33 +56719,33 @@ fn aiur_fn_674(
       3u64 => {
         match __v_11.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3, __v_14, __v_22, __v_24]; 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_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 __v_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_32]; 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_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 __v_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_30, __v_31, __v_33, __v_34]; 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 __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 __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_28, __v_29, __v_35, __v_36]; 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 __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 __v_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_37, __v_38]; 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 __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 __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_39, __v_40];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_39, __v_40];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56656,19 +56756,19 @@ fn aiur_fn_674(
       4u64 => {
         match __v_11.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_28, __v_29]; 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 __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 __v_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_30, __v_31];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_30, __v_31];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56679,27 +56779,27 @@ fn aiur_fn_674(
       0u64 => {
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_3, __v_14]; 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_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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_30]; 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_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 __v_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_28, __v_29, __v_31, __v_32]; 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 __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 __v_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_33, __v_34]; 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 __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 __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_35, __v_36];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_35, __v_36];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56710,61 +56810,61 @@ fn aiur_fn_674(
       5u64 => {
         match __v_11.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_17]; 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_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_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_3, __v_14]; 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_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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_31]; 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_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 __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_34]; 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_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 __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5]; 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_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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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_38: G = __r_arr[0];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_37, __v_38]; 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_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 __v_39: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_39]; 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_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 __v_40: G = __r_arr[0];
             let __v_41: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_5, __v_16, __v_22, __v_23, __v_24]; 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 __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 __v_44: G = __r_arr[0];
             let __v_45: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_42, __v_43, __v_44, __v_45]; 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 __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 __v_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_46, __v_47]; 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 __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 __v_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_35, __v_36, __v_48, __v_49]; 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 __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 __v_50: G = __r_arr[0];
             let __v_51: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_32, __v_33, __v_50, __v_51]; 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 __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 __v_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_29, __v_30, __v_52, __v_53]; 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 __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 __v_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_54, __v_55]; 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 __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 __v_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_56, __v_57];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_56, __v_57];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56775,43 +56875,43 @@ fn aiur_fn_674(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_16]; 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_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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_31]; 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_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 __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_17]; 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_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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_34]; 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_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 __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_35, __v_36, __v_37, __v_38]; 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 __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 __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_32, __v_33, __v_39, __v_40]; 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 __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 __v_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_29, __v_30, __v_41, __v_42]; 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 __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 __v_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+            let __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 __v_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_45, __v_46];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_45, __v_46];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56822,65 +56922,65 @@ fn aiur_fn_674(
       7u64 => {
         match __v_11.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_25]; 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_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 __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_3, __v_14]; 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_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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_28]; 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_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 __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_31]; 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_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 __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_16]; 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_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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_34]; 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_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 __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_17]; 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_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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_37]; 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_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 __v_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_8, __v_19]; 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_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_40: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_40]; 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_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 __v_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_24]; 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_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 __v_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_7, __v_18, __v_22, __v_24]; 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_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 __v_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+            let __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 __v_47: G = __r_arr[0];
             let __v_48: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_41, __v_42, __v_47, __v_48]; 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 __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 __v_49: G = __r_arr[0];
             let __v_50: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_38, __v_39, __v_49, __v_50]; 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 __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 __v_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_35, __v_36, __v_51, __v_52]; 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 __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 __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_32, __v_33, __v_53, __v_54]; 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 __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 __v_55: G = __r_arr[0];
             let __v_56: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_29, __v_30, __v_55, __v_56]; 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 __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 __v_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_26, __v_27, __v_57, __v_58]; 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 __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 __v_59: G = __r_arr[0];
             let __v_60: G = __r_arr[1];
-            let __ret: [G; OUT_674] = [__v_59, __v_60];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_678] = [__v_59, __v_60];
+            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56895,15 +56995,15 @@ fn aiur_fn_674(
   })
 }
 
-const INPUT_SIZE_675: usize = 5;
-const IN_675: usize = 5;
-const OUT_675: usize = 2;
-fn aiur_fn_675(
-  inp: [G; IN_675],
+const INPUT_SIZE_679: usize = 5;
+const IN_679: usize = 5;
+const OUT_679: usize = 2;
+fn aiur_fn_679(
+  inp: [G; IN_679],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_675], 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];
@@ -56916,11 +57016,11 @@ fn aiur_fn_675(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_675] = [__v_8, __v_9];
-        record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_679] = [__v_8, __v_9];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -56930,15 +57030,15 @@ fn aiur_fn_675(
         let __v_10: G = __loaded[2];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = []; 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_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 __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_675] = [__v_11, __v_12];
-            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_679] = [__v_11, __v_12];
+            record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_6]; 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_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 __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];
@@ -56952,7 +57052,7 @@ fn aiur_fn_675(
             let __v_20: G = __loaded[8];
             let __v_21: G = __loaded[9];
             let __v_22: G = __loaded[10];
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_9]; 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_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 __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];
@@ -56966,17 +57066,17 @@ fn aiur_fn_675(
             let __v_32: G = __loaded[8];
             let __v_33: G = __loaded[9];
             let __v_34: G = __loaded[10];
-            let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__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[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 __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 __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_7, __v_10, __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 __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 __v_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_35, __v_36, __v_37, __v_38]; 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 __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 __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_675] = [__v_39, __v_40];
-            record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_679] = [__v_39, __v_40];
+            record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56991,15 +57091,15 @@ fn aiur_fn_675(
   })
 }
 
-const INPUT_SIZE_676: usize = 24;
-const IN_676: usize = 24;
-const OUT_676: usize = 2;
-fn aiur_fn_676(
-  inp: [G; IN_676],
+const INPUT_SIZE_680: usize = 24;
+const IN_680: usize = 24;
+const OUT_680: usize = 2;
+fn aiur_fn_680(
+  inp: [G; IN_680],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_676], 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];
@@ -57029,88 +57129,88 @@ fn aiur_fn_676(
       6u64 => {
         match __v_11.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_12]; 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_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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_24]; 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_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 __v_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_15]; 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_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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_27]; 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_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 __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_16]; 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_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_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_30]; 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_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 __v_31: G = __r_arr[0];
             let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_17]; 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_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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_33]; 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_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 __v_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2, __v_13, __v_22, __v_23]; 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_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 __v_36: G = __r_arr[0];
             let __v_37: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_34, __v_35, __v_36, __v_37]; 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 __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 __v_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_31, __v_32, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+            let __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 __v_40: G = __r_arr[0];
             let __v_41: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_28, __v_29, __v_40, __v_41]; 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 __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 __v_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_25, __v_26, __v_42, __v_43]; 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 __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 __v_44: G = __r_arr[0];
             let __v_45: G = __r_arr[1];
-            let __ret: [G; OUT_676] = [__v_44, __v_45];
-            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_680] = [__v_44, __v_45];
+            record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_24, __v_25]; 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_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 __v_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_26]; 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_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 __v_27: G = __r_arr[0];
             let __v_28: G = __r_arr[1];
-            let __ret: [G; OUT_676] = [__v_27, __v_28];
-            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_680] = [__v_27, __v_28];
+            record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_24, __v_25]; 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_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 __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_26]; 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_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 __v_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
-        let __ret: [G; OUT_676] = [__v_27, __v_28];
-        record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_680] = [__v_27, __v_28];
+        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_677: usize = 4;
-const IN_677: usize = 4;
-const OUT_677: usize = 1;
-fn aiur_fn_677(
-  inp: [G; IN_677],
+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_677], 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];
@@ -57125,8 +57225,8 @@ fn aiur_fn_677(
         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_677] = [__v_9];
-        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_681] = [__v_9];
+        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57142,25 +57242,25 @@ fn aiur_fn_677(
         let __v_15: G = __loaded[8];
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
-        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, __v_2]; 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_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_677] = { let __args: [G; IN_677] = [__v_0, __v_6, __v_2, __v_20]; 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_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_126] = { let __args: [G; IN_126] = [__v_18, __v_0]; 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_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_677] = [__v_24];
-            record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_677] = [__v_21];
-            record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_681] = [__v_21];
+            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57175,15 +57275,15 @@ fn aiur_fn_677(
   })
 }
 
-const INPUT_SIZE_678: usize = 2;
-const IN_678: usize = 2;
-const OUT_678: usize = 0;
-fn aiur_fn_678(
-  inp: [G; IN_678],
+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_678], 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];
@@ -57224,22 +57324,22 @@ fn aiur_fn_678(
     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_680] = { let __args: [G; IN_680] = [__v_0, __v_34, __v_37, __v_38, __v_0, __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 __ret: [G; OUT_678] = [];
-    record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_679: usize = 12;
-const IN_679: usize = 12;
-const OUT_679: usize = 1;
-fn aiur_fn_679(
-  inp: [G; IN_679],
+const INPUT_SIZE_683: usize = 12;
+const IN_683: usize = 12;
+const OUT_683: usize = 1;
+fn aiur_fn_683(
+  inp: [G; IN_683],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_679], 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];
@@ -57255,12 +57355,12 @@ fn aiur_fn_679(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __ret: [G; OUT_679] = [__v_7];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_683] = [__v_7];
+        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_11, __v_3]; 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_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 __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];
@@ -57276,8 +57376,8 @@ fn aiur_fn_679(
         let __v_23: G = __loaded[10];
         match __v_13.as_canonical_u64() {
           5u64 => {
-            let __ret: [G; OUT_679] = [__v_20];
-            record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_683] = [__v_20];
+            record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -57314,15 +57414,15 @@ fn aiur_fn_679(
             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_679] = [__v_56];
-            record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_683] = [__v_56];
+            record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       7u64 => {
-        let __ret: [G; OUT_679] = [__v_10];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_683] = [__v_10];
+        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57359,23 +57459,23 @@ fn aiur_fn_679(
         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_679] = [__v_44];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_683] = [__v_44];
+        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_680: usize = 6;
-const IN_680: usize = 6;
-const OUT_680: usize = 0;
-fn aiur_fn_680(
-  inp: [G; IN_680],
+const INPUT_SIZE_684: usize = 6;
+const IN_684: usize = 6;
+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_680], 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];
@@ -57389,9 +57489,9 @@ fn aiur_fn_680(
     let __v_8: G = __loaded[2];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_1, __v_2, __v_4, __v_5]; 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_680] = [];
-        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -57407,30 +57507,30 @@ fn aiur_fn_680(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_20, __v_1]; 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_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 __v_21: G = __r_arr[0];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_2, __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 __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 __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_680] = { let __args: [G; IN_680] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_680] = [];
-            record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_1, __v_2, __v_4, __v_5]; 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_681] = { let __args: [G; IN_681] = [__v_20, __v_3]; 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_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 __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_680] = { let __args: [G; IN_680] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; 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 __ret: [G; OUT_680] = [];
-            record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -57445,15 +57545,15 @@ fn aiur_fn_680(
   })
 }
 
-const INPUT_SIZE_681: usize = 2;
-const IN_681: usize = 2;
-const OUT_681: usize = 1;
-fn aiur_fn_681(
-  inp: [G; IN_681],
+const INPUT_SIZE_685: usize = 2;
+const IN_685: usize = 2;
+const OUT_685: usize = 1;
+fn aiur_fn_685(
+  inp: [G; IN_685],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_681], 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];
@@ -57490,15 +57590,15 @@ fn aiur_fn_681(
     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_126] = { let __args: [G; IN_126] = [__v_0, __v_34]; 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_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 __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_681] = [__v_38];
-        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_685] = [__v_38];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -57507,8 +57607,8 @@ fn aiur_fn_681(
         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_681] = [__v_40];
-        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_685] = [__v_40];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57518,15 +57618,15 @@ fn aiur_fn_681(
   })
 }
 
-const INPUT_SIZE_682: usize = 4;
-const IN_682: usize = 4;
-const OUT_682: usize = 0;
-fn aiur_fn_682(
-  inp: [G; IN_682],
+const INPUT_SIZE_686: usize = 4;
+const IN_686: usize = 4;
+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_682], 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];
@@ -57565,32 +57665,32 @@ fn aiur_fn_682(
     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_126] = { let __args: [G; IN_126] = [__v_0, __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 __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 __v_37: G = __r_arr[0];
     match __v_37.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_682] = [];
-        record.function_queries[682].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 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __v_38: G = __r_arr[0];
         match __v_38.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_682] = [];
-            record.function_queries[682].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);
           },
           1u64 => {
-            let __ret: [G; OUT_682] = [];
-            record.function_queries[682].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);
           },
           _ => {
-            let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_1, __v_2, __v_3]; 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_682] = [];
-            record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -57602,42 +57702,42 @@ fn aiur_fn_682(
   })
 }
 
-const INPUT_SIZE_683: usize = 3;
-const IN_683: usize = 3;
-const OUT_683: usize = 0;
-fn aiur_fn_683(
-  inp: [G; IN_683],
+const INPUT_SIZE_687: usize = 3;
+const IN_687: usize = 3;
+const OUT_687: usize = 0;
+fn aiur_fn_687(
+  inp: [G; IN_687],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_683], ExecError> {
+) -> Result<[G; OUT_687], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__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 __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 __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_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 __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_683] = [];
-        record.function_queries[683].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);
       },
       1u64 => {
-        let __ret: [G; OUT_683] = [];
-        record.function_queries[683].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);
       },
       _ => {
-        let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_3, __v_1, __v_2]; 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_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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__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_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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_3]; 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_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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         if (__v_6 != __v_9) {
@@ -57647,23 +57747,23 @@ fn aiur_fn_683(
         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_683] = [];
-        record.function_queries[683].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);
       },
     }
   })
 }
 
-const INPUT_SIZE_684: usize = 2;
-const IN_684: usize = 2;
-const OUT_684: usize = 1;
-fn aiur_fn_684(
-  inp: [G; IN_684],
+const INPUT_SIZE_688: usize = 2;
+const IN_688: usize = 2;
+const OUT_688: usize = 1;
+fn aiur_fn_688(
+  inp: [G; IN_688],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_684], 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];
@@ -57676,12 +57776,12 @@ fn aiur_fn_684(
         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_684] = [__v_7];
-        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_688] = [__v_7];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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_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];
@@ -57695,21 +57795,21 @@ fn aiur_fn_684(
         let __v_14: G = __loaded[8];
         let __v_15: G = __loaded[9];
         let __v_16: G = __loaded[10];
-        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_4, __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 __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 __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__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[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 __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 __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_684] = [__v_20];
-            record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_688] = [__v_20];
+            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_684] = [__v_17];
-            record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_688] = [__v_17];
+            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57721,15 +57821,15 @@ fn aiur_fn_684(
   })
 }
 
-const INPUT_SIZE_685: usize = 1;
-const IN_685: usize = 1;
-const OUT_685: usize = 1;
-fn aiur_fn_685(
-  inp: [G; IN_685],
+const INPUT_SIZE_689: usize = 1;
+const IN_689: usize = 1;
+const OUT_689: usize = 1;
+fn aiur_fn_689(
+  inp: [G; IN_689],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_685], ExecError> {
+) -> Result<[G; OUT_689], 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 };
@@ -57739,25 +57839,25 @@ fn aiur_fn_685(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_685] = [__v_4];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_689] = [__v_4];
+        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__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_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 __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_685] = [__v_5];
-            record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_689] = [__v_5];
+            record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_685] = [__v_5];
-            record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_689] = [__v_5];
+            record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57769,15 +57869,15 @@ fn aiur_fn_685(
   })
 }
 
-const INPUT_SIZE_686: usize = 1;
-const IN_686: usize = 1;
-const OUT_686: usize = 1;
-fn aiur_fn_686(
-  inp: [G; IN_686],
+const INPUT_SIZE_690: usize = 1;
+const IN_690: usize = 1;
+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_686], ExecError> {
+) -> Result<[G; OUT_690], 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 };
@@ -57789,17 +57889,17 @@ fn aiur_fn_686(
         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_686] = [__v_6];
-        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_690] = [__v_6];
+        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_3]; 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_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 __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_686] = [__v_5];
-        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_690] = [__v_5];
+        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57809,15 +57909,15 @@ fn aiur_fn_686(
   })
 }
 
-const INPUT_SIZE_687: usize = 3;
-const IN_687: usize = 3;
-const OUT_687: usize = 1;
-fn aiur_fn_687(
-  inp: [G; IN_687],
+const INPUT_SIZE_691: usize = 3;
+const IN_691: usize = 3;
+const OUT_691: usize = 1;
+fn aiur_fn_691(
+  inp: [G; IN_691],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_687], 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];
@@ -57828,26 +57928,26 @@ fn aiur_fn_687(
     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_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __v_9: G = __r_arr[0];
     let __v_10: G = (__v_8 + __v_9);
-    let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_687] = [__v_11];
-    record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_691] = [__v_11];
+    record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_688: usize = 4;
-const IN_688: usize = 4;
-const OUT_688: usize = 1;
-fn aiur_fn_688(
-  inp: [G; IN_688],
+const INPUT_SIZE_692: usize = 4;
+const IN_692: usize = 4;
+const OUT_692: usize = 1;
+fn aiur_fn_692(
+  inp: [G; IN_692],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_688], 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];
@@ -57855,30 +57955,30 @@ fn aiur_fn_688(
     let __v_3: G = inp[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_688] = [__v_0];
-        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_692] = [__v_0];
+        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_1]; 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_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 __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_4, __v_1, __v_2]; 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_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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_5]; 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_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 __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_688] = [__v_0];
-            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_692] = [__v_0];
+            record.function_queries[692].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_688] = { let __args: [G; IN_688] = [__v_5, __v_1, __v_2, __v_8]; 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_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 __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_688] = [__v_9];
-            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_692] = [__v_9];
+            record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -57887,38 +57987,38 @@ fn aiur_fn_688(
   })
 }
 
-const INPUT_SIZE_689: usize = 2;
-const IN_689: usize = 2;
-const OUT_689: usize = 1;
-fn aiur_fn_689(
-  inp: [G; IN_689],
+const INPUT_SIZE_693: usize = 2;
+const IN_693: usize = 2;
+const OUT_693: usize = 1;
+fn aiur_fn_693(
+  inp: [G; IN_693],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_689], ExecError> {
+) -> Result<[G; OUT_693], ExecError> {
   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_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_1, __v_2, __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_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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_689] = [__v_4];
-    record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_693] = [__v_4];
+    record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_690: usize = 4;
-const IN_690: usize = 4;
-const OUT_690: usize = 1;
-fn aiur_fn_690(
-  inp: [G; IN_690],
+const INPUT_SIZE_694: usize = 4;
+const IN_694: usize = 4;
+const OUT_694: usize = 1;
+fn aiur_fn_694(
+  inp: [G; IN_694],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_690], 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];
@@ -57933,23 +58033,23 @@ fn aiur_fn_690(
         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_690] = [__v_9];
-        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_9];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+        let __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 __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_690] = { let __args: [G; IN_690] = [__v_6, __v_1, __v_10, __v_11]; 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_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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_7, __v_12]; 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_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 __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_690] = [__v_13];
-        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_694] = [__v_13];
+        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -57959,15 +58059,15 @@ fn aiur_fn_690(
   })
 }
 
-const INPUT_SIZE_691: usize = 4;
-const IN_691: usize = 4;
-const OUT_691: usize = 2;
-fn aiur_fn_691(
-  inp: [G; IN_691],
+const INPUT_SIZE_695: usize = 4;
+const IN_695: usize = 4;
+const OUT_695: usize = 2;
+fn aiur_fn_695(
+  inp: [G; IN_695],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_691], 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];
@@ -57983,15 +58083,15 @@ fn aiur_fn_691(
         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_691] = [__v_9, __v_10];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [__v_9, __v_10];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_5]; 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_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 __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];
@@ -58005,27 +58105,27 @@ fn aiur_fn_691(
         let __v_18: G = __loaded[8];
         let __v_19: G = __loaded[9];
         let __v_20: G = __loaded[10];
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__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[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_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 __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __v_22: G = __r_arr[0];
         let __v_23: G = G::from_u64(0);
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_21, __v_3, __v_23]; 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_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 __v_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(0);
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_24, __v_7]; 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_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 __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_691] = [__v_27, __v_22];
-            record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_695] = [__v_27, __v_22];
+            record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_691] = [__v_27, __v_8];
-            record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_695] = [__v_27, __v_8];
+            record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58037,15 +58137,15 @@ fn aiur_fn_691(
   })
 }
 
-const INPUT_SIZE_692: usize = 3;
-const IN_692: usize = 3;
-const OUT_692: usize = 1;
-fn aiur_fn_692(
-  inp: [G; IN_692],
+const INPUT_SIZE_696: usize = 3;
+const IN_696: usize = 3;
+const OUT_696: usize = 1;
+fn aiur_fn_696(
+  inp: [G; IN_696],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_692], 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];
@@ -58059,8 +58159,8 @@ fn aiur_fn_692(
         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_692] = [__v_8];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_696] = [__v_8];
+        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -58068,11 +58168,11 @@ fn aiur_fn_692(
         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_692] = { let __args: [G; IN_692] = [__v_5, __v_1, __v_9]; 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_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 __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_692] = [__v_11];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_696] = [__v_11];
+        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58082,15 +58182,15 @@ fn aiur_fn_692(
   })
 }
 
-const INPUT_SIZE_693: usize = 11;
-const IN_693: usize = 11;
-const OUT_693: usize = 1;
-fn aiur_fn_693(
-  inp: [G; IN_693],
+const INPUT_SIZE_697: usize = 11;
+const IN_697: usize = 11;
+const OUT_697: usize = 1;
+fn aiur_fn_697(
+  inp: [G; IN_697],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_693], 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];
@@ -58105,31 +58205,31 @@ fn aiur_fn_693(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __ret: [G; OUT_693] = [__v_5];
-        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_697] = [__v_5];
+        record.function_queries[697].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_693] = [__v_13];
-        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_697] = [__v_13];
+        record.function_queries[697].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_698: usize = 4;
+const IN_698: usize = 4;
+const OUT_698: usize = 1;
+fn aiur_fn_698(
+  inp: [G; IN_698],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_694], 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];
@@ -58144,19 +58244,19 @@ 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; 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_694] = [__v_9];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_698] = [__v_9];
+        record.function_queries[698].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_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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_6, __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_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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_694] = [__v_9];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_698] = [__v_9];
+        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58166,29 +58266,29 @@ fn aiur_fn_694(
   })
 }
 
-const INPUT_SIZE_695: usize = 4;
-const IN_695: usize = 4;
-const OUT_695: usize = 1;
-fn aiur_fn_695(
-  inp: [G; IN_695],
+const INPUT_SIZE_699: usize = 4;
+const IN_699: usize = 4;
+const OUT_699: usize = 1;
+fn aiur_fn_699(
+  inp: [G; IN_699],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_695], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; 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_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 __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_695] = [__v_7];
-        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_699] = [__v_7];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -58197,32 +58297,32 @@ fn aiur_fn_695(
         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_695] = [__v_9];
-        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_699] = [__v_9];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } };
+        let __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_5, __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_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 __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_695] = [__v_6];
-        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_699] = [__v_6];
+        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_696: usize = 4;
-const IN_696: usize = 4;
-const OUT_696: usize = 1;
-fn aiur_fn_696(
-  inp: [G; IN_696],
+const INPUT_SIZE_700: usize = 4;
+const IN_700: usize = 4;
+const OUT_700: usize = 1;
+fn aiur_fn_700(
+  inp: [G; IN_700],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_696], 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];
@@ -58237,17 +58337,17 @@ fn aiur_fn_696(
         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_696] = [__v_9];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_700] = [__v_9];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } };
+        let __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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_5, __v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } };
+        let __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 __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_696] = [__v_8];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_700] = [__v_8];
+        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58257,15 +58357,15 @@ fn aiur_fn_696(
   })
 }
 
-const INPUT_SIZE_697: usize = 5;
-const IN_697: usize = 5;
-const OUT_697: usize = 1;
-fn aiur_fn_697(
-  inp: [G; IN_697],
+const INPUT_SIZE_701: usize = 5;
+const IN_701: usize = 5;
+const OUT_701: usize = 1;
+fn aiur_fn_701(
+  inp: [G; IN_701],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_697], ExecError> {
+) -> Result<[G; OUT_701], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58283,12 +58383,12 @@ fn aiur_fn_697(
         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_697] = [__v_12];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_701] = [__v_12];
+        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __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_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 __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];
@@ -58302,7 +58402,7 @@ fn aiur_fn_697(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_6]; 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_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 __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];
@@ -58316,24 +58416,24 @@ fn aiur_fn_697(
         let __v_29: G = __loaded[8];
         let __v_30: G = __loaded[9];
         let __v_31: G = __loaded[10];
-        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__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[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_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 __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_697] = [__v_35];
-            record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_701] = [__v_35];
+            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_34: G = G::from_u64(0);
-            let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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_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 __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_697] = [__v_36];
-            record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_701] = [__v_36];
+            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58345,15 +58445,15 @@ fn aiur_fn_697(
   })
 }
 
-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_702: usize = 4;
+const IN_702: usize = 4;
+const OUT_702: usize = 1;
+fn aiur_fn_702(
+  inp: [G; IN_702],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_698], ExecError> {
+) -> Result<[G; OUT_702], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58368,8 +58468,8 @@ 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_702] = [__v_9];
+        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -58378,10 +58478,10 @@ fn aiur_fn_698(
         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_699] = { let __args: [G; IN_699] = [__v_6, __v_1, __v_2, __v_3, __v_5, __v_11]; 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_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 __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_698] = [__v_12];
-        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_702] = [__v_12];
+        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58391,15 +58491,15 @@ fn aiur_fn_698(
   })
 }
 
-const INPUT_SIZE_699: usize = 6;
-const IN_699: usize = 6;
-const OUT_699: usize = 1;
-fn aiur_fn_699(
-  inp: [G; IN_699],
+const INPUT_SIZE_703: usize = 6;
+const IN_703: usize = 6;
+const OUT_703: usize = 1;
+fn aiur_fn_703(
+  inp: [G; IN_703],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_699], 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];
@@ -58418,12 +58518,12 @@ fn aiur_fn_699(
         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_699] = [__v_13];
-        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_703] = [__v_13];
+        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_4]; 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_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 __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];
@@ -58437,7 +58537,7 @@ fn aiur_fn_699(
         let __v_18: G = __loaded[8];
         let __v_19: G = __loaded[9];
         let __v_20: G = __loaded[10];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __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_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 __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];
@@ -58451,17 +58551,17 @@ fn aiur_fn_699(
         let __v_30: G = __loaded[8];
         let __v_31: G = __loaded[9];
         let __v_32: G = __loaded[10];
-        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__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[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_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 __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_769] = { let __args: [G; IN_769] = [__v_5, __v_7]; 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 __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 __v_35: G = __r_arr[0];
-            let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_8, __v_1, __v_2, __v_3, __v_7, __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 __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 __v_36: G = __r_arr[0];
-            let __ret: [G; OUT_699] = [__v_36];
-            record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_703] = [__v_36];
+            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -58471,11 +58571,11 @@ fn aiur_fn_699(
             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_699] = { let __args: [G; IN_699] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_40]; 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_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 __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_699] = [__v_42];
-            record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_703] = [__v_42];
+            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58487,15 +58587,15 @@ fn aiur_fn_699(
   })
 }
 
-const INPUT_SIZE_700: usize = 2;
-const IN_700: usize = 2;
-const OUT_700: usize = 1;
-fn aiur_fn_700(
-  inp: [G; IN_700],
+const INPUT_SIZE_704: usize = 2;
+const IN_704: usize = 2;
+const OUT_704: usize = 1;
+fn aiur_fn_704(
+  inp: [G; IN_704],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_700], 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];
@@ -58512,14 +58612,14 @@ fn aiur_fn_700(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_700] = [__v_8];
-            record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_704] = [__v_8];
+            record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_700] = [__v_8];
-            record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_704] = [__v_8];
+            record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58532,25 +58632,25 @@ fn aiur_fn_700(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_700] = [__v_8];
-            record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_704] = [__v_8];
+            record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __v_6]; 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_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 __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_700] = [__v_9];
-                record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_704] = [__v_9];
+                record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_4, __v_7]; 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_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 __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_700] = [__v_9];
-                record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_704] = [__v_9];
+                record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -58567,15 +58667,15 @@ fn aiur_fn_700(
   })
 }
 
-const INPUT_SIZE_701: usize = 11;
-const IN_701: usize = 11;
-const OUT_701: usize = 1;
-fn aiur_fn_701(
-  inp: [G; IN_701],
+const INPUT_SIZE_705: usize = 11;
+const IN_705: usize = 11;
+const OUT_705: usize = 1;
+fn aiur_fn_705(
+  inp: [G; IN_705],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_701], ExecError> {
+) -> Result<[G; OUT_705], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58590,56 +58690,56 @@ fn aiur_fn_701(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_701] = [__v_3];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_3];
+        record.function_queries[705].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_701] = [__v_11];
-            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_705] = [__v_11];
+            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_701] = [__v_11];
-            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_705] = [__v_11];
+            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_701] = [__v_11];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_11];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_701] = [__v_4];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_4];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_701] = [__v_11];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_11];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_701] = [__v_6];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_6];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_701] = [__v_7];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_7];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_701] = [__v_9];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_9];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58649,15 +58749,15 @@ fn aiur_fn_701(
   })
 }
 
-const INPUT_SIZE_702: usize = 2;
-const IN_702: usize = 2;
-const OUT_702: usize = 1;
-fn aiur_fn_702(
-  inp: [G; IN_702],
+const INPUT_SIZE_706: usize = 2;
+const IN_706: usize = 2;
+const OUT_706: usize = 1;
+fn aiur_fn_706(
+  inp: [G; IN_706],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_702], ExecError> {
+) -> Result<[G; OUT_706], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58669,18 +58769,18 @@ fn aiur_fn_702(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_702] = [__v_6];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_6];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_702] = [__v_6];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_6];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; 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_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_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];
@@ -58695,67 +58795,67 @@ fn aiur_fn_702(
         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_701] = { let __args: [G; IN_701] = [__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[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_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 __v_19: G = __r_arr[0];
         let __v_20: G = (__v_18 - __v_19);
-        let __ret: [G; OUT_702] = [__v_20];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_20];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_3, __v_1]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4, __v_1]; 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_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 __v_7: G = __r_arr[0];
         let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_702] = [__v_8];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_8];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_3, __v_1]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4, __v_1]; 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_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 __v_7: G = __r_arr[0];
         let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_702] = [__v_8];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_8];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_3, __v_1]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4, __v_1]; 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_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 __v_7: G = __r_arr[0];
         let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_702] = [__v_8];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_8];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_3, __v_1]; 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_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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4, __v_1]; 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_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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_5, __v_1]; 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_706] = { let __args: [G; IN_706] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
         let __v_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_702] = [__v_10];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_10];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_702] = [__v_6];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_6];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_5, __v_1]; 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_706] = { let __args: [G; IN_706] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_702] = [__v_6];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_706] = [__v_6];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58765,34 +58865,34 @@ fn aiur_fn_702(
   })
 }
 
-const INPUT_SIZE_703: usize = 3;
-const IN_703: usize = 3;
-const OUT_703: usize = 0;
-fn aiur_fn_703(
-  inp: [G; IN_703],
+const INPUT_SIZE_707: usize = 3;
+const IN_707: usize = 3;
+const OUT_707: usize = 0;
+fn aiur_fn_707(
+  inp: [G; IN_707],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_703], 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];
     let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_703] = [];
-        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_707] = [];
+        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_1, __v_2]; 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_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 __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_703] = [];
-        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_707] = [];
+        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58802,15 +58902,15 @@ fn aiur_fn_703(
   })
 }
 
-const INPUT_SIZE_704: usize = 2;
-const IN_704: usize = 2;
-const OUT_704: usize = 0;
-fn aiur_fn_704(
-  inp: [G; IN_704],
+const INPUT_SIZE_708: usize = 2;
+const IN_708: usize = 2;
+const OUT_708: usize = 0;
+fn aiur_fn_708(
+  inp: [G; IN_708],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_704], ExecError> {
+) -> Result<[G; OUT_708], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58820,28 +58920,28 @@ fn aiur_fn_704(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_704] = [];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [];
+        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_704] = [];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_704] = [];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_704] = [];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       4u64 => {
@@ -58850,8 +58950,8 @@ fn aiur_fn_704(
         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_704] = [];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [];
+        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -58861,15 +58961,15 @@ fn aiur_fn_704(
   })
 }
 
-const INPUT_SIZE_705: usize = 2;
-const IN_705: usize = 2;
-const OUT_705: usize = 0;
-fn aiur_fn_705(
-  inp: [G; IN_705],
+const INPUT_SIZE_709: usize = 2;
+const IN_709: usize = 2;
+const OUT_709: usize = 0;
+fn aiur_fn_709(
+  inp: [G; IN_709],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_705], ExecError> {
+) -> Result<[G; OUT_709], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58879,15 +58979,15 @@ fn aiur_fn_705(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_705] = [];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_709] = [];
+        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_1]; 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 __ret: [G; OUT_705] = [];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -58897,15 +58997,15 @@ fn aiur_fn_705(
   })
 }
 
-const INPUT_SIZE_706: usize = 4;
-const IN_706: usize = 4;
-const OUT_706: usize = 0;
-fn aiur_fn_706(
-  inp: [G; IN_706],
+const INPUT_SIZE_710: usize = 4;
+const IN_710: usize = 4;
+const OUT_710: usize = 0;
+fn aiur_fn_710(
+  inp: [G; IN_710],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_706], 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];
@@ -58923,18 +59023,18 @@ fn aiur_fn_706(
         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_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_710] = [];
+        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_5, __v_2]; 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 __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_5]; 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_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 __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];
@@ -58948,62 +59048,62 @@ fn aiur_fn_706(
         let __v_17: G = __loaded[8];
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__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[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_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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_6]; 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_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 __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_705] = { let __args: [G; IN_705] = [__v_6, __v_2]; 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 __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_5, __v_1, __v_2, __v_3]; 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_706] = { let __args: [G; IN_706] = [__v_6, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_5, __v_1, __v_2, __v_3]; 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_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 __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_5, __v_1, __v_2, __v_3]; 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_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 __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_5, __v_1, __v_2, __v_3]; 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_706] = { let __args: [G; IN_706] = [__v_6, __v_1, __v_2, __v_3]; 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_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 __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_7, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_710] = [];
+        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_7, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_706] = [];
-        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -59013,15 +59113,15 @@ fn aiur_fn_706(
   })
 }
 
-const INPUT_SIZE_707: usize = 12;
-const IN_707: usize = 12;
-const OUT_707: usize = 0;
-fn aiur_fn_707(
-  inp: [G; IN_707],
+const INPUT_SIZE_711: usize = 12;
+const IN_711: usize = 12;
+const OUT_711: usize = 0;
+fn aiur_fn_711(
+  inp: [G; IN_711],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_707], ExecError> {
+) -> Result<[G; OUT_711], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59035,58 +59135,58 @@ fn aiur_fn_707(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__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[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_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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__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[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_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 __v_13: G = __r_arr[0];
     let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_13, __v_14, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+    let __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)? } };
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_707] = [];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_707] = [];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_707] = [];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_7, __v_12, __v_11]; 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_707] = [];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_707] = [];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_711] = [];
+        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_708: usize = 3;
-const IN_708: usize = 3;
-const OUT_708: usize = 0;
-fn aiur_fn_708(
-  inp: [G; IN_708],
+const INPUT_SIZE_712: usize = 3;
+const IN_712: usize = 3;
+const OUT_712: usize = 0;
+fn aiur_fn_712(
+  inp: [G; IN_712],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_708], ExecError> {
+) -> Result<[G; OUT_712], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59099,18 +59199,18 @@ fn aiur_fn_708(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_712] = [];
+        record.function_queries[712].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_706] = { let __args: [G; IN_706] = [__v_6, __v_8, __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_708] = { let __args: [G; IN_708] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_708] = [];
-            record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -59122,24 +59222,24 @@ 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_713: usize = 2;
+const IN_713: usize = 2;
+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_709], ExecError> {
+) -> Result<[G; OUT_713], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_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_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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_2, __v_1, __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_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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; 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_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 __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];
@@ -59155,35 +59255,35 @@ fn aiur_fn_709(
     let __v_16: G = __loaded[10];
     match __v_6.as_canonical_u64() {
       5u64 => {
-        let __v_17: G = G::from_u64(1);
-        if (__v_7 != __v_17) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
-        }
-        let __v_18: G = G::from_u64(2);
-        if (__v_9 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !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_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 __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 __v_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(1);
-        if (__v_19 != __v_20) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
+        if (__v_7 != __v_20) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
         }
-        let __v_21: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_11, __v_21]; 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 __v_21: G = G::from_u64(2);
+        if (__v_9 != __v_21) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
+        }
+        let __r_arr: [G; OUT_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 __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_22]; 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 __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
+        let __v_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_23, __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_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 __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_709] = [];
-        record.function_queries[709].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);
       },
       _ => {
@@ -59193,15 +59293,15 @@ fn aiur_fn_709(
   })
 }
 
-const INPUT_SIZE_710: usize = 14;
-const IN_710: usize = 14;
-const OUT_710: usize = 0;
-fn aiur_fn_710(
-  inp: [G; IN_710],
+const INPUT_SIZE_714: usize = 14;
+const IN_714: usize = 14;
+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_710], 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];
@@ -59217,83 +59317,83 @@ fn aiur_fn_710(
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
-    let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __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_701] = { let __args: [G; IN_701] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_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 __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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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 __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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_703] = { let __args: [G; IN_703] = [__v_14, __v_3, __v_12]; 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_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 __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_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __v_19: G = G::from_u64(0);
-        let __v_20: G = G::from_u64(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 __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_225] = { let __args: [G; IN_225] = [__v_18, __v_21]; 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_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_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 __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 __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 __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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_703] = { let __args: [G; IN_703] = [__v_14, __v_3, __v_12]; 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_24: G = G::from_u64(1);
-        let __v_25: G = G::from_u64(1);
-        let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_26, __v_12, __v_13]; 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 __ret: [G; OUT_710] = [];
-        record.function_queries[710].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);
       },
       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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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_703] = { let __args: [G; IN_703] = [__v_14, __v_3, __v_12]; 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_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)? } };
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_710] = [];
-            record.function_queries[710].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 __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_451] = { let __args: [G; IN_451] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_710] = [];
-            record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -59305,38 +59405,38 @@ fn aiur_fn_710(
         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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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_777] = { let __args: [G; IN_777] = [__v_13, __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_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 __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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_637] = { let __args: [G; IN_637] = [__v_11, __v_2, __v_3, __v_4, __v_7, __v_12, __v_13]; 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_499] = { let __args: [G; IN_499] = [__v_11, __v_12, __v_13]; 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 __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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_582] = { let __args: [G; IN_582] = [__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[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_777] = { let __args: [G; IN_777] = [__v_12, __v_3]; 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_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 __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];
@@ -59352,27 +59452,27 @@ fn aiur_fn_710(
         let __v_30: G = __loaded[10];
         match __v_20.as_canonical_u64() {
           5u64 => {
-            if (__v_5 != __v_23) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
-            }
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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_498] = { let __args: [G; IN_498] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21, __v_12]; 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_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 __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_504] = { let __args: [G; IN_504] = [__v_22, __v_31, __v_34, __v_12, __v_13]; 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 __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 __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_505] = { let __args: [G; IN_505] = [__v_2, __v_5, __v_35, __v_38, __v_12, __v_13]; 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_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 __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_508] = { let __args: [G; IN_508] = [__v_2, __v_5, __v_3, __v_41, __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 __ret: [G; OUT_710] = [];
-            record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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)? } };
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -59384,12 +59484,12 @@ fn aiur_fn_710(
         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_450] = { let __args: [G; IN_450] = [__v_2, __v_17, __v_12, __v_13]; 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_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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_14, __v_2, __v_12]; 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_587] = { let __args: [G; IN_587] = [__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[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 __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -59399,15 +59499,15 @@ fn aiur_fn_710(
   })
 }
 
-const INPUT_SIZE_711: usize = 6;
-const IN_711: usize = 6;
-const OUT_711: usize = 0;
-fn aiur_fn_711(
-  inp: [G; IN_711],
+const INPUT_SIZE_715: usize = 6;
+const IN_715: usize = 6;
+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_711], 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];
@@ -59417,9 +59517,9 @@ fn aiur_fn_711(
     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_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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; 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_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 __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
@@ -59430,9 +59530,9 @@ fn aiur_fn_711(
     break '__mc_0 [__v_9, __v_10];
   },
   1u64 => {
-    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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; 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_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 __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
@@ -59443,23 +59543,23 @@ fn aiur_fn_711(
     break '__mc_0 [__v_9, __v_10];
   },
   2u64 => {
-    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 __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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; 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_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 __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
     }
-    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_4, __v_5]; 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_9: G = G::from_u64(2);
     let __v_10: G = G::from_u64(6);
     break '__mc_0 [__v_9, __v_10];
   },
   3u64 => {
-    let __r_arr: [G; OUT_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 __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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_6]; 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_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 __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
@@ -59480,27 +59580,27 @@ fn aiur_fn_711(
       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_712] = { let __args: [G; IN_712] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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_711] = [];
-    record.function_queries[711].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);
   })
 }
 
-const INPUT_SIZE_712: usize = 3;
-const IN_712: usize = 3;
-const OUT_712: usize = 1;
-fn aiur_fn_712(
-  inp: [G; IN_712],
+const INPUT_SIZE_716: usize = 3;
+const IN_716: usize = 3;
+const OUT_716: usize = 1;
+fn aiur_fn_716(
+  inp: [G; IN_716],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_712], 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];
@@ -59509,8 +59609,8 @@ fn aiur_fn_712(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_712] = [__v_4];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_716] = [__v_4];
+        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59523,16 +59623,16 @@ fn aiur_fn_712(
           5u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 + __v_8);
-            let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_712] = [__v_10];
-            record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_716] = [__v_10];
+            record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_712] = [__v_8];
-            record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_716] = [__v_8];
+            record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -59541,37 +59641,37 @@ fn aiur_fn_712(
   })
 }
 
-const INPUT_SIZE_713: usize = 3;
-const IN_713: usize = 3;
-const OUT_713: usize = 0;
-fn aiur_fn_713(
-  inp: [G; IN_713],
+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_713], 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];
-    let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_1, __v_2]; 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_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 __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_1, __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 __ret: [G; OUT_713] = [];
-    record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_714: usize = 4;
-const IN_714: usize = 4;
-const OUT_714: usize = 0;
-fn aiur_fn_714(
-  inp: [G; IN_714],
+const INPUT_SIZE_718: usize = 4;
+const IN_718: usize = 4;
+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_714], 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];
@@ -59583,8 +59683,8 @@ fn aiur_fn_714(
     let __v_6: G = __loaded[2];
     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_718] = [];
+        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -59600,12 +59700,12 @@ fn aiur_fn_714(
         let __v_15: G = __loaded[8];
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__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[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_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 __v_18: G = G::from_u64(1);
         let __v_19: G = (__v_3 + __v_18);
-        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_6, __v_1, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __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));
         return Ok(__ret);
       },
       _ => {
@@ -59615,35 +59715,35 @@ fn aiur_fn_714(
   })
 }
 
-const INPUT_SIZE_715: usize = 1;
-const IN_715: usize = 1;
-const OUT_715: usize = 3;
-fn aiur_fn_715(
-  inp: [G; IN_715],
+const INPUT_SIZE_719: usize = 1;
+const IN_719: usize = 1;
+const OUT_719: usize = 3;
+fn aiur_fn_719(
+  inp: [G; IN_719],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_715], ExecError> {
+) -> Result<[G; OUT_719], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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_715] = [__v_3, __v_4, __v_2];
-        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_719] = [__v_3, __v_4, __v_2];
+        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_2]; 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_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 = G::from_u64(0);
-        let __ret: [G; OUT_715] = [__v_5, __v_3, __v_4];
-        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_719] = [__v_5, __v_3, __v_4];
+        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59653,15 +59753,15 @@ fn aiur_fn_715(
   })
 }
 
-const INPUT_SIZE_716: usize = 2;
-const IN_716: usize = 2;
-const OUT_716: usize = 10;
-fn aiur_fn_716(
-  inp: [G; IN_716],
+const INPUT_SIZE_720: usize = 2;
+const IN_720: usize = 2;
+const OUT_720: usize = 10;
+fn aiur_fn_720(
+  inp: [G; IN_720],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_716], 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];
@@ -59669,12 +59769,12 @@ fn aiur_fn_716(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_716] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; 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_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -59685,23 +59785,23 @@ fn aiur_fn_716(
         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_716] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_717: usize = 2;
-const IN_717: usize = 2;
-const OUT_717: usize = 3;
-fn aiur_fn_717(
-  inp: [G; IN_717],
+const INPUT_SIZE_721: usize = 2;
+const IN_721: usize = 2;
+const OUT_721: usize = 3;
+fn aiur_fn_721(
+  inp: [G; IN_721],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_717], 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];
@@ -59709,32 +59809,32 @@ fn aiur_fn_717(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_717] = [__v_2, __v_3, __v_1];
-        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_721] = [__v_2, __v_3, __v_1];
+        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_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 = G::from_u64(0);
-        let __ret: [G; OUT_717] = [__v_4, __v_2, __v_3];
-        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_721] = [__v_4, __v_2, __v_3];
+        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_718: usize = 2;
-const IN_718: usize = 2;
-const OUT_718: usize = 3;
-fn aiur_fn_718(
-  inp: [G; IN_718],
+const INPUT_SIZE_722: usize = 2;
+const IN_722: usize = 2;
+const OUT_722: usize = 3;
+fn aiur_fn_722(
+  inp: [G; IN_722],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_718], 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];
@@ -59742,32 +59842,32 @@ fn aiur_fn_718(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_718] = [__v_2, __v_3, __v_1];
-        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_722] = [__v_2, __v_3, __v_1];
+        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+        let __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 __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_718] = [__v_4, __v_2, __v_3];
-        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_722] = [__v_4, __v_2, __v_3];
+        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_719: usize = 2;
-const IN_719: usize = 2;
-const OUT_719: usize = 3;
-fn aiur_fn_719(
-  inp: [G; IN_719],
+const INPUT_SIZE_723: usize = 2;
+const IN_723: usize = 2;
+const OUT_723: usize = 3;
+fn aiur_fn_723(
+  inp: [G; IN_723],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_719], 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];
@@ -59775,34 +59875,34 @@ fn aiur_fn_719(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_719] = [__v_2, __v_3, __v_1];
-        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1];
+        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+        let __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 __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_719] = [__v_4, __v_5, __v_3];
-            record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_723] = [__v_4, __v_5, __v_3];
+            record.function_queries[723].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_719] = [__v_4, __v_5, __v_3];
-            record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_723] = [__v_4, __v_5, __v_3];
+            record.function_queries[723].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_719] = [__v_4, __v_5, __v_3];
-            record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_723] = [__v_4, __v_5, __v_3];
+            record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59814,15 +59914,15 @@ fn aiur_fn_719(
   })
 }
 
-const INPUT_SIZE_720: usize = 2;
-const IN_720: usize = 2;
-const OUT_720: usize = 3;
-fn aiur_fn_720(
-  inp: [G; IN_720],
+const INPUT_SIZE_724: usize = 2;
+const IN_724: usize = 2;
+const OUT_724: usize = 3;
+fn aiur_fn_724(
+  inp: [G; IN_724],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_720], 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];
@@ -59830,41 +59930,41 @@ 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_1];
-        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_724] = [__v_2, __v_3, __v_1];
+        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+        let __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 __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_720] = [__v_4, __v_5, __v_3];
-            record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3];
+            record.function_queries[724].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_720] = [__v_4, __v_5, __v_3];
-            record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3];
+            record.function_queries[724].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_720] = [__v_4, __v_5, __v_3];
-            record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3];
+            record.function_queries[724].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_720] = [__v_4, __v_5, __v_3];
-            record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3];
+            record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59876,15 +59976,15 @@ fn aiur_fn_720(
   })
 }
 
-const INPUT_SIZE_721: usize = 9;
-const IN_721: usize = 9;
-const OUT_721: usize = 2;
-fn aiur_fn_721(
-  inp: [G; IN_721],
+const INPUT_SIZE_725: usize = 9;
+const IN_725: usize = 9;
+const OUT_725: usize = 2;
+fn aiur_fn_725(
+  inp: [G; IN_725],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_721], 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];
@@ -59902,12 +60002,12 @@ fn aiur_fn_721(
         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_721] = [__v_12, __v_0];
-        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_725] = [__v_12, __v_0];
+        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -59926,7 +60026,7 @@ fn aiur_fn_721(
         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_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 __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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -59935,28 +60035,28 @@ fn aiur_fn_721(
         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_721] = { let __args: [G; IN_721] = [__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[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_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 __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_721] = [__v_39, __v_37];
-        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_725] = [__v_39, __v_37];
+        record.function_queries[725].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_726: usize = 2;
+const IN_726: usize = 2;
+const OUT_726: usize = 3;
+fn aiur_fn_726(
+  inp: [G; IN_726],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_722], ExecError> {
+) -> Result<[G; OUT_726], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59964,12 +60064,12 @@ 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_726] = [__v_2, __v_3, __v_1];
+        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; 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_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -59979,30 +60079,30 @@ fn aiur_fn_722(
         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_721] = { let __args: [G; IN_721] = [__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[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_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 __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_722] = [__v_13, __v_11, __v_12];
-        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_726] = [__v_13, __v_11, __v_12];
+        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_723: usize = 1;
-const IN_723: usize = 1;
-const OUT_723: usize = 41;
-fn aiur_fn_723(
-  inp: [G; IN_723],
+const INPUT_SIZE_727: usize = 1;
+const IN_727: usize = 1;
+const OUT_727: usize = 41;
+fn aiur_fn_727(
+  inp: [G; IN_727],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_723], ExecError> {
+) -> Result<[G; OUT_727], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -60021,11 +60121,11 @@ fn aiur_fn_723(
     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_718] = { let __args: [G; IN_718] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+    let __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 __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_716] = { let __args: [G; IN_716] = [__v_11, __v_20]; 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_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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -60036,7 +60136,7 @@ fn aiur_fn_723(
     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_716] = { let __args: [G; IN_716] = [__v_12, __v_30]; 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_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 __v_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -60047,7 +60147,7 @@ fn aiur_fn_723(
     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_716] = { let __args: [G; IN_716] = [__v_13, __v_40]; 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_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 __v_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -60058,7 +60158,7 @@ fn aiur_fn_723(
     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_716] = { let __args: [G; IN_716] = [__v_14, __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_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 __v_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -60069,28 +60169,28 @@ fn aiur_fn_723(
     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_717] = { let __args: [G; IN_717] = [__v_15, __v_60]; 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 __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 __v_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
-    let __ret: [G; OUT_723] = [__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[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_724: usize = 1;
-const IN_724: usize = 1;
-const OUT_724: usize = 49;
-fn aiur_fn_724(
-  inp: [G; IN_724],
+const INPUT_SIZE_728: usize = 1;
+const IN_728: usize = 1;
+const OUT_728: usize = 49;
+fn aiur_fn_728(
+  inp: [G; IN_728],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_724], 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_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -60100,7 +60200,7 @@ fn aiur_fn_724(
     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_723] = { let __args: [G; IN_723] = [__v_9]; 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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -60142,21 +60242,21 @@ fn aiur_fn_724(
     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_724] = [__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[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-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_729: usize = 9;
+const IN_729: usize = 9;
+const OUT_729: usize = 2;
+fn aiur_fn_729(
+  inp: [G; IN_729],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_725], ExecError> {
+) -> Result<[G; OUT_729], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60174,12 +60274,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; 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_725] = [__v_12, __v_0];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_729] = [__v_12, __v_0];
+        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0]; 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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60229,7 +60329,7 @@ fn aiur_fn_725(
         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_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 __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 __v_59: G = __r_arr[0];
         let __v_60: G = __r_arr[1];
         let __v_61: G = __r_arr[2];
@@ -60238,28 +60338,28 @@ fn aiur_fn_725(
         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_725] = { let __args: [G; IN_725] = [__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[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_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 __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_725] = [__v_70, __v_68];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_729] = [__v_70, __v_68];
+        record.function_queries[729].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_730: usize = 2;
+const IN_730: usize = 2;
+const OUT_730: usize = 3;
+fn aiur_fn_730(
+  inp: [G; IN_730],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_726], 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];
@@ -60267,12 +60367,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_730] = [__v_2, __v_3, __v_1];
+        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; 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_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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -60282,33 +60382,33 @@ 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_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 __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_730] = [__v_13, __v_11, __v_12];
+        record.function_queries[730].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 = 55;
-fn aiur_fn_727(
-  inp: [G; IN_727],
+const INPUT_SIZE_731: usize = 1;
+const IN_731: usize = 1;
+const OUT_731: usize = 55;
+fn aiur_fn_731(
+  inp: [G; IN_731],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_727], ExecError> {
+) -> Result<[G; OUT_731], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -60338,15 +60438,15 @@ fn aiur_fn_727(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; 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_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 __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_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; 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_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 __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_716] = { let __args: [G; IN_716] = [__v_14, __v_33]; 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_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 __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60357,26 +60457,26 @@ fn aiur_fn_727(
         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_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __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 __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_717] = { let __args: [G; IN_717] = [__v_16, __v_46]; 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 __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 __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_727] = [__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[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_11]; 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_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_13, __v_30]; 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_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 __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60387,7 +60487,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_716] = { let __args: [G; IN_716] = [__v_14, __v_40]; 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_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 __v_41: G = __r_arr[0];
         let __v_42: G = __r_arr[1];
         let __v_43: G = __r_arr[2];
@@ -60398,7 +60498,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_716] = { let __args: [G; IN_716] = [__v_15, __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_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 __v_51: G = __r_arr[0];
         let __v_52: G = __r_arr[1];
         let __v_53: G = __r_arr[2];
@@ -60409,30 +60509,30 @@ 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_717] = { let __args: [G; IN_717] = [__v_16, __v_60]; 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 __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 __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_726] = { let __args: [G; IN_726] = [__v_17, __v_63]; 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_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 __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_727] = [__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[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_11]; 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_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_30]; 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_722] = { let __args: [G; IN_722] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_14, __v_33]; 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_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 __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60443,7 +60543,7 @@ fn aiur_fn_727(
         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_716] = { let __args: [G; IN_716] = [__v_15, __v_43]; 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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -60454,7 +60554,7 @@ fn aiur_fn_727(
         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_716] = { let __args: [G; IN_716] = [__v_16, __v_53]; 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_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 __v_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -60465,7 +60565,7 @@ fn aiur_fn_727(
         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_716] = { let __args: [G; IN_716] = [__v_17, __v_63]; 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_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 __v_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -60476,7 +60576,7 @@ fn aiur_fn_727(
         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_716] = { let __args: [G; IN_716] = [__v_18, __v_73]; 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_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 __v_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -60487,17 +60587,17 @@ fn aiur_fn_727(
         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_717] = { let __args: [G; IN_717] = [__v_19, __v_83]; 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 __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 __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_722] = { let __args: [G; IN_722] = [__v_20, __v_86]; 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_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 __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_727] = [__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[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -60507,18 +60607,18 @@ fn aiur_fn_727(
   })
 }
 
-const INPUT_SIZE_728: usize = 1;
-const IN_728: usize = 1;
-const OUT_728: usize = 63;
-fn aiur_fn_728(
-  inp: [G; IN_728],
+const INPUT_SIZE_732: usize = 1;
+const IN_732: usize = 1;
+const OUT_732: usize = 63;
+fn aiur_fn_732(
+  inp: [G; IN_732],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_728], ExecError> {
+) -> Result<[G; OUT_732], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -60528,7 +60628,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_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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -60584,21 +60684,21 @@ fn aiur_fn_728(
     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_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, __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[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     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_733: usize = 9;
+const IN_733: usize = 9;
+const OUT_733: usize = 2;
+fn aiur_fn_733(
+  inp: [G; IN_733],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_729], 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];
@@ -60616,12 +60716,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; 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_729] = [__v_12, __v_0];
-        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_733] = [__v_12, __v_0];
+        record.function_queries[733].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_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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60685,7 +60785,7 @@ fn aiur_fn_729(
         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_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 __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 __v_73: G = __r_arr[0];
         let __v_74: G = __r_arr[1];
         let __v_75: G = __r_arr[2];
@@ -60694,34 +60794,34 @@ fn aiur_fn_729(
         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_729] = { let __args: [G; IN_729] = [__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[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_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 __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_729] = [__v_84, __v_82];
-        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_733] = [__v_84, __v_82];
+        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_730: usize = 1;
-const IN_730: usize = 1;
-const OUT_730: usize = 55;
-fn aiur_fn_730(
-  inp: [G; IN_730],
+const INPUT_SIZE_734: usize = 1;
+const IN_734: usize = 1;
+const OUT_734: usize = 55;
+fn aiur_fn_734(
+  inp: [G; IN_734],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_730], ExecError> {
+) -> Result<[G; OUT_734], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2]; 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_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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -60751,15 +60851,15 @@ fn aiur_fn_730(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; 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_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 __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_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; 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_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 __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_716] = { let __args: [G; IN_716] = [__v_14, __v_33]; 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_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 __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60770,30 +60870,30 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __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 __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_717] = { let __args: [G; IN_717] = [__v_16, __v_46]; 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 __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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_11]; 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_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_30]; 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_722] = { let __args: [G; IN_722] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_14, __v_33]; 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_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 __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60804,7 +60904,7 @@ fn aiur_fn_730(
         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_716] = { let __args: [G; IN_716] = [__v_15, __v_43]; 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_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 __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -60815,7 +60915,7 @@ fn aiur_fn_730(
         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_716] = { let __args: [G; IN_716] = [__v_16, __v_53]; 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_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 __v_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -60826,7 +60926,7 @@ fn aiur_fn_730(
         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_716] = { let __args: [G; IN_716] = [__v_17, __v_63]; 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_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 __v_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -60837,7 +60937,7 @@ fn aiur_fn_730(
         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_716] = { let __args: [G; IN_716] = [__v_18, __v_73]; 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_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 __v_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -60848,25 +60948,25 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_19, __v_83]; 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 __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 __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_722] = { let __args: [G; IN_722] = [__v_20, __v_86]; 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_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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_11]; 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_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_13, __v_30]; 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_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 __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60877,22 +60977,22 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; 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 __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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
-        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_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_13, __v_30]; 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_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 __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60903,18 +61003,18 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; 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 __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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_11]; 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_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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60925,7 +61025,7 @@ fn aiur_fn_730(
         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_716] = { let __args: [G; IN_716] = [__v_13, __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_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 __v_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         let __v_40: G = __r_arr[2];
@@ -60936,18 +61036,18 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_14, __v_47]; 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 __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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_11]; 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_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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60958,18 +61058,18 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; 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 __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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_11]; 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_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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60980,18 +61080,18 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; 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 __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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_12, __v_11]; 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_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 __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61002,14 +61102,14 @@ fn aiur_fn_730(
         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_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; 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 __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 __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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       8u64 => {
@@ -61021,7 +61121,7 @@ fn aiur_fn_730(
     break '__mc_0 [__v_30, __v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_11]; 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_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 __v_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -61031,7 +61131,7 @@ fn aiur_fn_730(
     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_729] = { let __args: [G; IN_729] = [__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[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_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 __v_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     break '__mc_0 [__v_37, __v_38];
@@ -61045,8 +61145,8 @@ fn aiur_fn_730(
         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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -61056,18 +61156,18 @@ fn aiur_fn_730(
   })
 }
 
-const INPUT_SIZE_731: usize = 1;
-const IN_731: usize = 1;
-const OUT_731: usize = 57;
-fn aiur_fn_731(
-  inp: [G; IN_731],
+const INPUT_SIZE_735: usize = 1;
+const IN_735: usize = 1;
+const OUT_735: usize = 57;
+fn aiur_fn_735(
+  inp: [G; IN_735],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_731], ExecError> {
+) -> Result<[G; OUT_735], 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_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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -61084,55 +61184,55 @@ fn aiur_fn_731(
     }
     match __v_2.as_canonical_u64() {
       3u64 => {
-        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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        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_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 __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_15]; 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_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 __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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       4u64 => {
-        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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__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 __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 __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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       5u64 => {
-        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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__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 __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 __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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       6u64 => {
-        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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_13]; 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_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 __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = __r_arr[2];
@@ -61189,21 +61289,21 @@ fn aiur_fn_731(
         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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        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_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 __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_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -61213,15 +61313,15 @@ fn aiur_fn_731(
   })
 }
 
-const INPUT_SIZE_732: usize = 32;
-const IN_732: usize = 32;
-const OUT_732: usize = 56;
-fn aiur_fn_732(
-  inp: [G; IN_732],
+const INPUT_SIZE_736: usize = 32;
+const IN_736: usize = 32;
+const OUT_736: usize = 56;
+fn aiur_fn_736(
+  inp: [G; IN_736],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_732], 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];
@@ -61262,8 +61362,8 @@ fn aiur_fn_732(
     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_18] = { let __args: [G; IN_18] = [__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[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_731] = { let __args: [G; IN_731] = [__v_36]; 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_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 __v_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     let __v_39: G = __r_arr[2];
@@ -61336,21 +61436,21 @@ fn aiur_fn_732(
     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_732] = [__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[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_733: usize = 1;
-const IN_733: usize = 1;
-const OUT_733: usize = 1;
-fn aiur_fn_733(
-  inp: [G; IN_733],
+const INPUT_SIZE_737: usize = 1;
+const IN_737: usize = 1;
+const OUT_737: usize = 1;
+fn aiur_fn_737(
+  inp: [G; IN_737],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_733], ExecError> {
+) -> Result<[G; OUT_737], 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 };
@@ -61375,44 +61475,44 @@ fn aiur_fn_733(
     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_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_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[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_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 __v_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_23: G = __r_arr[0];
-    let __ret: [G; OUT_733] = [__v_23];
-    record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_737] = [__v_23];
+    record.function_queries[737].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 = 1;
-fn aiur_fn_734(
-  inp: [G; IN_734],
+const INPUT_SIZE_738: usize = 1;
+const IN_738: usize = 1;
+const OUT_738: usize = 1;
+fn aiur_fn_738(
+  inp: [G; IN_738],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_734], ExecError> {
+) -> Result<[G; OUT_738], 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_734] = [__v_1];
-        record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_738] = [__v_1];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_734] = [__v_1];
-        record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_738] = [__v_1];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_734] = [__v_1];
-        record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_738] = [__v_1];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61422,35 +61522,35 @@ fn aiur_fn_734(
   })
 }
 
-const INPUT_SIZE_735: usize = 3;
-const IN_735: usize = 3;
-const OUT_735: usize = 0;
-fn aiur_fn_735(
-  inp: [G; IN_735],
+const INPUT_SIZE_739: usize = 3;
+const IN_739: usize = 3;
+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_735], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_735] = [];
-        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_739] = [];
+        record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_2]; 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_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 __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_735] = [];
-        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_739] = [];
+        record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61460,35 +61560,35 @@ fn aiur_fn_735(
   })
 }
 
-const INPUT_SIZE_736: usize = 3;
-const IN_736: usize = 3;
-const OUT_736: usize = 0;
-fn aiur_fn_736(
-  inp: [G; IN_736],
+const INPUT_SIZE_740: usize = 3;
+const IN_740: usize = 3;
+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_736], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_736] = [];
-        record.function_queries[736].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);
       },
       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_100] = { let __args: [G; IN_100] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __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_736] = [];
-        record.function_queries[736].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);
       },
       _ => {
@@ -61498,31 +61598,31 @@ fn aiur_fn_736(
   })
 }
 
-const INPUT_SIZE_737: usize = 3;
-const IN_737: usize = 3;
-const OUT_737: usize = 0;
-fn aiur_fn_737(
-  inp: [G; IN_737],
+const INPUT_SIZE_741: usize = 3;
+const IN_741: usize = 3;
+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_737], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_737] = [];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_741] = [];
+        record.function_queries[741].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_737] = [];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_741] = [];
+        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61532,15 +61632,15 @@ fn aiur_fn_737(
   })
 }
 
-const INPUT_SIZE_738: usize = 17;
-const IN_738: usize = 17;
-const OUT_738: usize = 0;
-fn aiur_fn_738(
-  inp: [G; IN_738],
+const INPUT_SIZE_742: usize = 17;
+const IN_742: usize = 17;
+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_738], 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];
@@ -61561,8 +61661,8 @@ fn aiur_fn_738(
     let __v_16: G = inp[16];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_738] = [];
-        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_742] = [];
+        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -61590,8 +61690,8 @@ fn aiur_fn_738(
         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_738] = [];
-        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_742] = [];
+        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61601,23 +61701,23 @@ 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_743: usize = 3;
+const IN_743: usize = 3;
+const OUT_743: usize = 0;
+fn aiur_fn_743(
+  inp: [G; IN_743],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_739], 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];
     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_743] = [];
+        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -61783,8 +61883,8 @@ fn aiur_fn_739(
         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_739] = [];
-        record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_743] = [];
+        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61794,27 +61894,27 @@ 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_744: usize = 3;
+const IN_744: usize = 3;
+const OUT_744: usize = 0;
+fn aiur_fn_744(
+  inp: [G; IN_744],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_740], ExecError> {
+) -> Result<[G; OUT_744], ExecError> {
   stacker::maybe_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_744] = [];
+        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; 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_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 __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];
@@ -61978,8 +62078,8 @@ fn aiur_fn_740(
         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_740] = [];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_744] = [];
+        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61989,15 +62089,15 @@ fn aiur_fn_740(
   })
 }
 
-const INPUT_SIZE_741: usize = 2;
-const IN_741: usize = 2;
-const OUT_741: usize = 0;
-fn aiur_fn_741(
-  inp: [G; IN_741],
+const INPUT_SIZE_745: usize = 2;
+const IN_745: usize = 2;
+const OUT_745: usize = 0;
+fn aiur_fn_745(
+  inp: [G; IN_745],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_741], ExecError> {
+) -> Result<[G; OUT_745], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62037,8 +62137,8 @@ fn aiur_fn_741(
         let __v_31: G = __loaded[10];
         match __v_21.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_741] = [];
-            record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_745] = [];
+            record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -62065,6 +62165,8 @@ fn aiur_fn_741(
               _ => {
                 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)? } };
                     if (__v_22 != __v_11) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
                     }
@@ -62089,11 +62191,9 @@ fn aiur_fn_741(
                     if (__v_29 != __v_18) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
                     }
-                    let __v_32: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_30, __v_32, __v_19]; 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_741] = { let __args: [G; IN_741] = [__v_31, __v_20]; 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 __ret: [G; OUT_741] = [];
-                    record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -62112,29 +62212,29 @@ fn aiur_fn_741(
   })
 }
 
-const INPUT_SIZE_742: usize = 3;
-const IN_742: usize = 3;
-const OUT_742: usize = 0;
-fn aiur_fn_742(
-  inp: [G; IN_742],
+const INPUT_SIZE_746: usize = 3;
+const IN_746: usize = 3;
+const OUT_746: usize = 0;
+fn aiur_fn_746(
+  inp: [G; IN_746],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_742], 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];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_742] = [];
-        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_746] = [];
+        record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_2]; 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 __ret: [G; OUT_742] = [];
-        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -62144,15 +62244,15 @@ fn aiur_fn_742(
   })
 }
 
-const INPUT_SIZE_743: usize = 49;
-const IN_743: usize = 49;
-const OUT_743: usize = 0;
-fn aiur_fn_743(
-  inp: [G; IN_743],
+const INPUT_SIZE_747: usize = 49;
+const IN_747: usize = 49;
+const OUT_747: usize = 0;
+fn aiur_fn_747(
+  inp: [G; IN_747],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_743], 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];
@@ -62203,7 +62303,7 @@ fn aiur_fn_743(
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
     let __v_48: G = inp[48];
-    let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__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[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_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 __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
     let __v_51: G = __r_arr[2];
@@ -62242,14 +62342,14 @@ fn aiur_fn_743(
       _ => {
         match __v_49.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; 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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; 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_743] = [];
-            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -62258,15 +62358,15 @@ fn aiur_fn_743(
   })
 }
 
-const INPUT_SIZE_744: usize = 2;
-const IN_744: usize = 2;
-const OUT_744: usize = 0;
-fn aiur_fn_744(
-  inp: [G; IN_744],
+const INPUT_SIZE_748: usize = 2;
+const IN_748: usize = 2;
+const OUT_748: usize = 0;
+fn aiur_fn_748(
+  inp: [G; IN_748],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_744], 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];
@@ -62323,15 +62423,15 @@ fn aiur_fn_744(
     let __v_51: G = __loaded[49];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_744] = [];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_748] = [];
+        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__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[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; 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_744] = [];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -62341,29 +62441,29 @@ fn aiur_fn_744(
   })
 }
 
-const INPUT_SIZE_745: usize = 3;
-const IN_745: usize = 3;
-const OUT_745: usize = 0;
-fn aiur_fn_745(
-  inp: [G; IN_745],
+const INPUT_SIZE_749: usize = 3;
+const IN_749: usize = 3;
+const OUT_749: usize = 0;
+fn aiur_fn_749(
+  inp: [G; IN_749],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_745], ExecError> {
+) -> Result<[G; OUT_749], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_745] = [];
-        record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_749] = [];
+        record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; 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_745] = [];
-        record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -62373,15 +62473,15 @@ fn aiur_fn_745(
   })
 }
 
-const INPUT_SIZE_746: usize = 99;
-const IN_746: usize = 99;
-const OUT_746: usize = 0;
-fn aiur_fn_746(
-  inp: [G; IN_746],
+const INPUT_SIZE_750: usize = 99;
+const IN_750: usize = 99;
+const OUT_750: usize = 0;
+fn aiur_fn_750(
+  inp: [G; IN_750],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_746], ExecError> {
+) -> Result<[G; OUT_750], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62488,13 +62588,13 @@ fn aiur_fn_746(
           0u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_46, __v_47]; 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_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; 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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; 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_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; 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_746] = [];
-                record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -62509,14 +62609,14 @@ fn aiur_fn_746(
           1u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; 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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; 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_745] = { let __args: [G; IN_745] = [__v_27, __v_77, __v_78]; 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_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));
                 return Ok(__ret);
               },
             }
@@ -62531,17 +62631,17 @@ fn aiur_fn_746(
           2u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; 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_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; 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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; 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_44, __v_97, __v_98]; 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 __ret: [G; OUT_746] = [];
-                record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -62558,15 +62658,15 @@ fn aiur_fn_746(
   })
 }
 
-const INPUT_SIZE_747: usize = 2;
-const IN_747: usize = 2;
-const OUT_747: usize = 0;
-fn aiur_fn_747(
-  inp: [G; IN_747],
+const INPUT_SIZE_751: usize = 2;
+const IN_751: usize = 2;
+const OUT_751: usize = 0;
+fn aiur_fn_751(
+  inp: [G; IN_751],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_747], 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];
@@ -62637,12 +62737,12 @@ fn aiur_fn_747(
     let __v_65: G = __loaded[63];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_747] = [];
-        record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_751] = [];
+        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__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[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_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 __v_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -62688,10 +62788,10 @@ fn aiur_fn_747(
         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_746] = { let __args: [G; IN_746] = [__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[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_747] = [];
-        record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -62701,91 +62801,91 @@ fn aiur_fn_747(
   })
 }
 
-const INPUT_SIZE_748: usize = 1;
-const IN_748: usize = 1;
-const OUT_748: usize = 1;
-fn aiur_fn_748(
-  inp: [G; IN_748],
+const INPUT_SIZE_752: usize = 1;
+const IN_752: usize = 1;
+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_748], ExecError> {
+) -> Result<[G; OUT_752], 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_43] = { let __args: [G; IN_43] = [__v_0, __v_3]; 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_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 __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_19] = { let __args: [G; IN_19] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_748] = [__v_8];
-    record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_752] = [__v_8];
+    record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_749: usize = 2;
-const IN_749: usize = 2;
-const OUT_749: usize = 1;
-fn aiur_fn_749(
-  inp: [G; IN_749],
+const INPUT_SIZE_753: usize = 2;
+const IN_753: usize = 2;
+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_749], ExecError> {
+) -> Result<[G; OUT_753], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __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_43] = { let __args: [G; IN_43] = [__v_1, __v_4]; 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_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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __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 __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 __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_19] = { let __args: [G; IN_19] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_749] = [__v_10];
-    record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_753] = [__v_10];
+    record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_750: usize = 1;
-const IN_750: usize = 1;
-const OUT_750: usize = 3;
-fn aiur_fn_750(
-  inp: [G; IN_750],
+const INPUT_SIZE_754: usize = 1;
+const IN_754: usize = 1;
+const OUT_754: usize = 3;
+fn aiur_fn_754(
+  inp: [G; IN_754],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_750], ExecError> {
+) -> Result<[G; OUT_754], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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_83] = { let __args: [G; IN_83] = [__v_2]; 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_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 __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_3]; 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 __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 __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_750] = [__v_5, __v_10, __v_4];
-        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_754] = [__v_5, __v_10, __v_4];
+        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -62825,25 +62925,25 @@ fn aiur_fn_750(
         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_750] = [__v_35, __v_38, __v_2];
-        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_754] = [__v_35, __v_38, __v_2];
+        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
+        let __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 __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_750] = { let __args: [G; IN_750] = [__v_5]; 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_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 __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_749] = { let __args: [G; IN_749] = [__v_3, __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 __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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_750] = [__v_9, __v_10, __v_8];
-        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_754] = [__v_9, __v_10, __v_8];
+        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62853,15 +62953,15 @@ fn aiur_fn_750(
   })
 }
 
-const INPUT_SIZE_751: usize = 1;
-const IN_751: usize = 1;
-const OUT_751: usize = 1;
-fn aiur_fn_751(
-  inp: [G; IN_751],
+const INPUT_SIZE_755: usize = 1;
+const IN_755: usize = 1;
+const OUT_755: usize = 1;
+fn aiur_fn_755(
+  inp: [G; IN_755],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_751], ExecError> {
+) -> Result<[G; OUT_755], 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 };
@@ -62904,7 +63004,7 @@ fn aiur_fn_751(
     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_74] = { let __args: [G; IN_74] = [__v_37]; 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_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 __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -62915,177 +63015,177 @@ fn aiur_fn_751(
     let __v_45: G = __r_arr[7];
     let __v_46: G = __r_arr[8];
     let __v_47: G = __r_arr[9];
-    let __v_48: G = G::from_u64(14);
-    if (__v_38 != __v_48) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_48.as_canonical_u64() });
-    }
-    let __v_49: G = G::from_u64(2);
-    if (__v_39 != __v_49) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_49.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_47]; 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_50: G = __r_arr[0];
-    let __v_51: G = __r_arr[1];
-    let __v_52: G = __r_arr[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_52.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_53: G = __loaded[0];
-    let __v_54: G = __loaded[1];
-    let __v_55: G = __loaded[2];
-    let __v_56: G = G::from_u64(1);
-    let __v_57: G = G::from_u64(1);
-    if (__v_53 != __v_56) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
-    }
-    if (__v_54 != __v_57) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_57.as_canonical_u64() });
-    }
-    if (__v_55 != __v_57) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_57.as_canonical_u64() });
-    }
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-    let __v_58: G = __loaded[0];
-    let __v_59: G = __loaded[1];
-    let __v_60: G = __loaded[2];
-    let __v_61: G = __loaded[3];
-    let __v_62: G = __loaded[4];
-    let __v_63: G = __loaded[5];
-    let __v_64: G = __loaded[6];
-    let __v_65: G = __loaded[7];
-    let __v_66: G = __loaded[8];
-    let __v_67: G = __loaded[9];
-    let __v_68: G = __loaded[10];
-    let __v_69: G = __loaded[11];
-    let __v_70: G = __loaded[12];
-    let __v_71: G = __loaded[13];
-    let __v_72: G = __loaded[14];
-    let __v_73: G = __loaded[15];
-    let __v_74: G = __loaded[16];
-    let __v_75: G = __loaded[17];
-    let __v_76: G = __loaded[18];
-    let __v_77: G = __loaded[19];
-    let __v_78: G = __loaded[20];
-    let __v_79: G = __loaded[21];
-    let __v_80: G = __loaded[22];
-    let __v_81: G = __loaded[23];
-    let __v_82: G = __loaded[24];
-    let __v_83: G = __loaded[25];
-    let __v_84: G = __loaded[26];
-    let __v_85: G = __loaded[27];
-    let __v_86: G = __loaded[28];
-    let __v_87: G = __loaded[29];
-    let __v_88: G = __loaded[30];
-    let __v_89: G = __loaded[31];
-    if (__v_58 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
-    }
-    if (__v_59 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
-    }
-    if (__v_60 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_3.as_canonical_u64() });
-    }
-    if (__v_61 != __v_4) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
-    }
-    if (__v_62 != __v_5) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
-    }
-    if (__v_63 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
-    }
-    if (__v_64 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
-    }
-    if (__v_65 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
-    }
-    if (__v_66 != __v_9) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
-    }
-    if (__v_67 != __v_10) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
-    }
-    if (__v_68 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
-    }
-    if (__v_69 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
-    }
-    if (__v_70 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
-    }
-    if (__v_71 != __v_14) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
-    }
-    if (__v_72 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
-    }
-    if (__v_73 != __v_16) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
+    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 __v_48: G = __r_arr[0];
+    let __v_49: G = __r_arr[1];
+    let __v_50: G = __r_arr[2];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_51: G = __loaded[0];
+    let __v_52: G = __loaded[1];
+    let __v_53: G = __loaded[2];
+    let __v_54: G = __loaded[3];
+    let __v_55: G = __loaded[4];
+    let __v_56: G = __loaded[5];
+    let __v_57: G = __loaded[6];
+    let __v_58: G = __loaded[7];
+    let __v_59: G = __loaded[8];
+    let __v_60: G = __loaded[9];
+    let __v_61: G = __loaded[10];
+    let __v_62: G = __loaded[11];
+    let __v_63: G = __loaded[12];
+    let __v_64: G = __loaded[13];
+    let __v_65: G = __loaded[14];
+    let __v_66: G = __loaded[15];
+    let __v_67: G = __loaded[16];
+    let __v_68: G = __loaded[17];
+    let __v_69: G = __loaded[18];
+    let __v_70: G = __loaded[19];
+    let __v_71: G = __loaded[20];
+    let __v_72: G = __loaded[21];
+    let __v_73: G = __loaded[22];
+    let __v_74: G = __loaded[23];
+    let __v_75: G = __loaded[24];
+    let __v_76: G = __loaded[25];
+    let __v_77: G = __loaded[26];
+    let __v_78: G = __loaded[27];
+    let __v_79: G = __loaded[28];
+    let __v_80: G = __loaded[29];
+    let __v_81: G = __loaded[30];
+    let __v_82: G = __loaded[31];
+    let __v_83: G = G::from_u64(14);
+    if (__v_38 != __v_83) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_83.as_canonical_u64() });
+    }
+    let __v_84: G = G::from_u64(2);
+    if (__v_39 != __v_84) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64() });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_85: G = __loaded[0];
+    let __v_86: G = __loaded[1];
+    let __v_87: G = __loaded[2];
+    let __v_88: G = G::from_u64(1);
+    let __v_89: G = G::from_u64(1);
+    if (__v_85 != __v_88) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_88.as_canonical_u64() });
+    }
+    if (__v_86 != __v_89) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_89.as_canonical_u64() });
+    }
+    if (__v_87 != __v_89) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_89.as_canonical_u64() });
+    }
+    if (__v_51 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
+    }
+    if (__v_52 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
+    }
+    if (__v_53 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_3.as_canonical_u64() });
+    }
+    if (__v_54 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
+    }
+    if (__v_55 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+    }
+    if (__v_56 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
+    }
+    if (__v_57 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
+    }
+    if (__v_58 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
+    }
+    if (__v_59 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
+    }
+    if (__v_60 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
+    }
+    if (__v_61 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
+    }
+    if (__v_62 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+    }
+    if (__v_63 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
+    }
+    if (__v_64 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+    }
+    if (__v_65 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+    }
+    if (__v_66 != __v_16) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
     }
-    if (__v_74 != __v_17) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
+    if (__v_67 != __v_17) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
     }
-    if (__v_75 != __v_18) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
+    if (__v_68 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
     }
-    if (__v_76 != __v_19) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
+    if (__v_69 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
     }
-    if (__v_77 != __v_20) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
+    if (__v_70 != __v_20) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
     }
-    if (__v_78 != __v_21) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
+    if (__v_71 != __v_21) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
     }
-    if (__v_79 != __v_22) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
+    if (__v_72 != __v_22) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
     }
-    if (__v_80 != __v_23) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+    if (__v_73 != __v_23) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
     }
-    if (__v_81 != __v_24) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+    if (__v_74 != __v_24) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
     }
-    if (__v_82 != __v_25) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_25.as_canonical_u64() });
+    if (__v_75 != __v_25) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_25.as_canonical_u64() });
     }
-    if (__v_83 != __v_26) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
+    if (__v_76 != __v_26) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
     }
-    if (__v_84 != __v_27) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_27.as_canonical_u64() });
+    if (__v_77 != __v_27) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_27.as_canonical_u64() });
     }
-    if (__v_85 != __v_28) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
+    if (__v_78 != __v_28) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
     }
-    if (__v_86 != __v_29) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_29.as_canonical_u64() });
+    if (__v_79 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_29.as_canonical_u64() });
     }
-    if (__v_87 != __v_30) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_30.as_canonical_u64() });
+    if (__v_80 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_30.as_canonical_u64() });
     }
-    if (__v_88 != __v_31) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
+    if (__v_81 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
     }
-    if (__v_89 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
+    if (__v_82 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
     }
-    let __ret: [G; OUT_751] = [__v_51];
-    record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_755] = [__v_49];
+    record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_752: usize = 2;
-const IN_752: usize = 2;
-const OUT_752: usize = 1;
-fn aiur_fn_752(
-  inp: [G; IN_752],
+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_752], 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];
@@ -63096,25 +63196,25 @@ fn aiur_fn_752(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_752] = [__v_5];
-        record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_756] = [__v_5];
+        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __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_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 __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_752] = [__v_6];
-            record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_756] = [__v_6];
+            record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_0, __v_4]; 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_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 __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_752] = [__v_6];
-            record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_756] = [__v_6];
+            record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -63126,15 +63226,15 @@ fn aiur_fn_752(
   })
 }
 
-const INPUT_SIZE_753: usize = 1;
-const IN_753: usize = 1;
-const OUT_753: usize = 1;
-fn aiur_fn_753(
-  inp: [G; IN_753],
+const INPUT_SIZE_757: usize = 1;
+const IN_757: usize = 1;
+const OUT_757: usize = 1;
+fn aiur_fn_757(
+  inp: [G; IN_757],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_753], ExecError> {
+) -> Result<[G; OUT_757], 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 };
@@ -63179,21 +63279,21 @@ fn aiur_fn_753(
     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_753] = [__v_41];
-    record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_757] = [__v_41];
+    record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_754: usize = 7;
-const IN_754: usize = 7;
-const OUT_754: usize = 6;
-fn aiur_fn_754(
-  inp: [G; IN_754],
+const INPUT_SIZE_758: usize = 7;
+const IN_758: usize = 7;
+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_754], 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];
@@ -63208,29 +63308,29 @@ fn aiur_fn_754(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_754] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_8]; 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_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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__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[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_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 __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_754] = { let __args: [G; IN_754] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_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 __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_754] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -63240,15 +63340,15 @@ fn aiur_fn_754(
   })
 }
 
-const INPUT_SIZE_755: usize = 7;
-const IN_755: usize = 7;
-const OUT_755: usize = 1;
-fn aiur_fn_755(
-  inp: [G; IN_755],
+const INPUT_SIZE_759: usize = 7;
+const IN_759: usize = 7;
+const OUT_759: usize = 1;
+fn aiur_fn_759(
+  inp: [G; IN_759],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_755], ExecError> {
+) -> Result<[G; OUT_759], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63257,7 +63357,7 @@ fn aiur_fn_755(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0]; 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_757] = { let __args: [G; IN_757] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
@@ -63292,34 +63392,34 @@ fn aiur_fn_755(
     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_773] = { let __args: [G; IN_773] = [__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[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_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 __v_41: G = __r_arr[0];
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_41, __v_0]; 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_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 __v_42: G = __r_arr[0];
-    let __ret: [G; OUT_755] = [__v_42];
-    record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_759] = [__v_42];
+    record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_756: usize = 4;
-const IN_756: usize = 4;
-const OUT_756: usize = 0;
-fn aiur_fn_756(
-  inp: [G; IN_756],
+const INPUT_SIZE_760: usize = 4;
+const IN_760: usize = 4;
+const OUT_760: usize = 0;
+fn aiur_fn_760(
+  inp: [G; IN_760],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_756], 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];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_1, __v_2]; 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_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 __v_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(1);
-    let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __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_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 __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -63327,22 +63427,22 @@ fn aiur_fn_756(
     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_757] = { let __args: [G; IN_757] = [__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[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 __ret: [G; OUT_756] = [];
-    record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_757: usize = 10;
-const IN_757: usize = 10;
-const OUT_757: usize = 0;
-fn aiur_fn_757(
-  inp: [G; IN_757],
+const INPUT_SIZE_761: usize = 10;
+const IN_761: usize = 10;
+const OUT_761: usize = 0;
+fn aiur_fn_761(
+  inp: [G; IN_761],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_757], 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];
@@ -63360,8 +63460,8 @@ fn aiur_fn_757(
     let __v_12: G = __loaded[2];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_757] = [];
-        record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_761] = [];
+        record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -63377,26 +63477,26 @@ fn aiur_fn_757(
         let __v_21: G = __loaded[8];
         let __v_22: G = __loaded[9];
         let __v_23: G = __loaded[10];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_9]; 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_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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_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 __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_757] = { let __args: [G; IN_757] = [__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[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 __ret: [G; OUT_757] = [];
-            record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__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[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_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 __v_26: G = G::from_u64(1);
             let __v_27: G = (__v_9 + __v_26);
-            let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__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[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 __ret: [G; OUT_757] = [];
-            record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -63408,35 +63508,35 @@ fn aiur_fn_757(
   })
 }
 
-const INPUT_SIZE_758: usize = 3;
-const IN_758: usize = 3;
-const OUT_758: usize = 0;
-fn aiur_fn_758(
-  inp: [G; IN_758],
+const INPUT_SIZE_762: usize = 3;
+const IN_762: usize = 3;
+const OUT_762: usize = 0;
+fn aiur_fn_762(
+  inp: [G; IN_762],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_758], ExecError> {
+) -> Result<[G; OUT_762], ExecError> {
   stacker::maybe_grow(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_191] = { let __args: [G; IN_191] = [__v_0]; 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_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 __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_713] = { let __args: [G; IN_713] = [__v_3, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_758] = [];
-        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__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 __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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } else { aiur_fn_756(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_758] = [];
-        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -63446,63 +63546,63 @@ fn aiur_fn_758(
   })
 }
 
-const INPUT_SIZE_759: usize = 2;
-const IN_759: usize = 2;
-const OUT_759: usize = 0;
-fn aiur_fn_759(
-  inp: [G; IN_759],
+const INPUT_SIZE_763: usize = 2;
+const IN_763: usize = 2;
+const OUT_763: usize = 0;
+fn aiur_fn_763(
+  inp: [G; IN_763],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_759], 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_751] = { let __args: [G; IN_751] = [__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 __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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_2]; 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_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 __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_759] = [];
-    record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_763] = [];
+    record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_760: usize = 3;
-const IN_760: usize = 3;
-const OUT_760: usize = 0;
-fn aiur_fn_760(
-  inp: [G; IN_760],
+const INPUT_SIZE_764: usize = 3;
+const IN_764: usize = 3;
+const OUT_764: usize = 0;
+fn aiur_fn_764(
+  inp: [G; IN_764],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_760], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__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 __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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_3]; 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_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 __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_713] = { let __args: [G; IN_713] = [__v_4, __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 __ret: [G; OUT_760] = [];
-        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__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 __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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_4, __v_4, __v_5, __v_6]; 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 __ret: [G; OUT_760] = [];
-        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -63512,15 +63612,15 @@ fn aiur_fn_760(
   })
 }
 
-const INPUT_SIZE_761: usize = 55;
-const IN_761: usize = 55;
-const OUT_761: usize = 0;
-fn aiur_fn_761(
-  inp: [G; IN_761],
+const INPUT_SIZE_765: usize = 55;
+const IN_765: usize = 55;
+const OUT_765: usize = 0;
+fn aiur_fn_765(
+  inp: [G; IN_765],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_761], 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];
@@ -63577,7 +63677,7 @@ fn aiur_fn_761(
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
     let __v_54: G = inp[54];
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0]; 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_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 __v_55: G = __r_arr[0];
     let __v_56: G = __r_arr[1];
     let __v_57: G = __r_arr[2];
@@ -63634,13 +63734,13 @@ fn aiur_fn_761(
               0u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_56, __v_2, __v_3]; 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_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; 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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; 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_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; 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_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63655,17 +63755,17 @@ fn aiur_fn_761(
               1u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; 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_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; 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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; 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_99, __v_53, __v_54]; 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 __ret: [G; OUT_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63680,11 +63780,11 @@ fn aiur_fn_761(
               2u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; 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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; 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_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63699,11 +63799,11 @@ fn aiur_fn_761(
               3u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; 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_738] = { let __args: [G; IN_738] = [__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[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_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; 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_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63718,11 +63818,11 @@ fn aiur_fn_761(
               4u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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[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_738] = { let __args: [G; IN_738] = [__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[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_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; 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_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63737,10 +63837,10 @@ fn aiur_fn_761(
               5u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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[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_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; 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_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63755,10 +63855,10 @@ fn aiur_fn_761(
               6u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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[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_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; 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_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63773,10 +63873,10 @@ fn aiur_fn_761(
               7u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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[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_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; 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_761] = [];
-                    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -63789,9 +63889,9 @@ fn aiur_fn_761(
           8u64 => {
             match __v_1.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_761] = [];
-                record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
@@ -63808,15 +63908,15 @@ fn aiur_fn_761(
   })
 }
 
-const INPUT_SIZE_762: usize = 4;
-const IN_762: usize = 4;
-const OUT_762: usize = 0;
-fn aiur_fn_762(
-  inp: [G; IN_762],
+const INPUT_SIZE_766: usize = 4;
+const IN_766: usize = 4;
+const OUT_766: usize = 0;
+fn aiur_fn_766(
+  inp: [G; IN_766],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_762], ExecError> {
+) -> Result<[G; OUT_766], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63827,21 +63927,21 @@ fn aiur_fn_762(
     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_762] = [];
-    record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_766] = [];
+    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_763: usize = 32;
-const IN_763: usize = 32;
-const OUT_763: usize = 0;
-fn aiur_fn_763(
-  inp: [G; IN_763],
+const INPUT_SIZE_767: usize = 32;
+const IN_767: usize = 32;
+const OUT_767: usize = 0;
+fn aiur_fn_767(
+  inp: [G; IN_767],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_763], ExecError> {
+) -> Result<[G; OUT_767], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63875,7 +63975,7 @@ fn aiur_fn_763(
     let __v_29: G = inp[29];
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
-    let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __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[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_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 __v_32: G = __r_arr[0];
     let __v_33: G = __r_arr[1];
     let __v_34: G = __r_arr[2];
@@ -63934,33 +64034,33 @@ fn aiur_fn_763(
     let __v_87: G = __r_arr[55];
     match __v_32.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33, __v_34, __v_35, __v_36]; 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_763] = [];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33, __v_34, __v_35]; 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 __ret: [G; OUT_763] = [];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_33, __v_34, __v_35]; 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_763] = [];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__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[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_763] = [];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_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));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_33, __v_34]; 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 __ret: [G; OUT_763] = [];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -63970,15 +64070,15 @@ fn aiur_fn_763(
   })
 }
 
-const INPUT_SIZE_764: usize = 32;
-const IN_764: usize = 32;
-const OUT_764: usize = 0;
-fn aiur_fn_764(
-  inp: [G; IN_764],
+const INPUT_SIZE_768: usize = 32;
+const IN_768: usize = 32;
+const OUT_768: usize = 0;
+fn aiur_fn_768(
+  inp: [G; IN_768],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_764], 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];
@@ -64013,13 +64113,13 @@ fn aiur_fn_764(
     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_191] = { let __args: [G; IN_191] = [__v_32]; 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_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 __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_465] = { let __args: [G; IN_465] = [__v_32, __v_34, __v_35]; 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_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 __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_33, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 __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];
@@ -64033,28 +64133,28 @@ fn aiur_fn_764(
     let __v_46: G = __loaded[8];
     let __v_47: G = __loaded[9];
     let __v_48: G = __loaded[10];
-    let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__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[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_764] = [];
-    record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_765: usize = 1;
-const IN_765: usize = 1;
-const OUT_765: usize = 0;
-fn aiur_fn_765(
-  inp: [G; IN_765],
+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_765], ExecError> {
+) -> 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_765] = [];
-        record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_769] = [];
+        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64067,7 +64167,7 @@ fn aiur_fn_765(
         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_107] = { let __args: [G; IN_107] = [__v_7]; 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_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];
@@ -64117,47 +64217,47 @@ fn aiur_fn_765(
         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_57: G = __loaded[0];
-        let __v_58: G = __loaded[1];
-        let __v_59: G = __loaded[2];
-        let __v_60: G = G::from_u64(1);
-        let __v_61: G = G::from_u64(1);
-        if (__v_57 != __v_60) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
+        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_58 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_61.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_59 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.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 __v_62: G = G::from_u64(1);
-        let __v_63: G = G::from_u64(1);
-        let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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_64]; 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_65: G = __r_arr[0];
-        if (__v_7 != __v_65) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_7.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_765] = { let __args: [G; IN_765] = [__v_2]; 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_765] = [];
-        record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_766: usize = 0;
-const IN_766: usize = 0;
-const OUT_766: usize = 0;
-fn aiur_fn_766(
-  inp: [G; IN_766],
+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_766], ExecError> {
+) -> 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);
@@ -64176,161 +64276,161 @@ fn aiur_fn_766(
     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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __v_18: G = G::from_u64(1);
-    if (__v_17 != __v_18) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
+    let __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_224] = { let __args: [G; IN_224] = [__v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = G::from_u64(1);
-    if (__v_19 != __v_20) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.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_224] = { let __args: [G; IN_224] = [__v_6, __v_10]; 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_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 __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_224] = { let __args: [G; IN_224] = [__v_13, __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_23: G = __r_arr[0];
-    let __v_24: G = G::from_u64(1);
-    if (__v_23 != __v_24) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+    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_224] = { let __args: [G; IN_224] = [__v_13, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __v_26: G = G::from_u64(0);
-    if (__v_25 != __v_26) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
+    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_224] = { let __args: [G; IN_224] = [__v_6, __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_27: G = __r_arr[0];
-    let __v_28: G = G::from_u64(1);
-    if (__v_27 != __v_28) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
+    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 __v_29: G = G::from_u64(2);
-    let __v_30: G = { let __values: [G; 3] = [__v_29, __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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_30, __v_30]; 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 __v_32: G = G::from_u64(1);
-    if (__v_31 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.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_224] = { let __args: [G; IN_224] = [__v_6, __v_30]; 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_33: G = __r_arr[0];
-    let __v_34: G = G::from_u64(1);
-    if (__v_33 != __v_34) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64() });
+    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_224] = { let __args: [G; IN_224] = [__v_30, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    let __v_36: G = G::from_u64(0);
-    if (__v_35 != __v_36) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.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 __v_37: G = G::from_u64(3);
-    let __v_38: G = { let __values: [G; 3] = [__v_37, __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 __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_38, __v_30]; 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_39: G = __r_arr[0];
-    let __v_40: G = G::from_u64(1);
-    if (__v_39 != __v_40) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64() });
+    let __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_224] = { let __args: [G; IN_224] = [__v_30, __v_38]; 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_41: G = __r_arr[0];
-    let __v_42: G = G::from_u64(0);
-    if (__v_41 != __v_42) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64() });
-    }
-    let __v_43: G = G::from_u64(2);
-    let __v_44: G = G::from_u64(3);
-    let __v_45: G = { let __values: [G; 3] = [__v_44, __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_46: G = { let __values: [G; 3] = [__v_43, __v_16, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_13, __v_46]; 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_47: G = __r_arr[0];
-    let __v_48: G = G::from_u64(1);
-    if (__v_47 != __v_48) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_48.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 __v_49: G = G::from_u64(3);
-    let __v_50: G = { let __values: [G; 3] = [__v_49, __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_225] = { let __args: [G; IN_225] = [__v_50, __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_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_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_53: G = G::from_u64(2);
-    let __v_54: G = { let __values: [G; 3] = [__v_53, __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_225] = { let __args: [G; IN_225] = [__v_54, __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_55: G = __r_arr[0];
-    let __v_56: G = G::from_u64(1);
-    if (__v_55 != __v_56) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.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_57: G = G::from_u64(1);
-    let __v_58: G = G::from_u64(0);
-    let __v_59: G = { let __values: [G; 3] = [__v_57, __v_10, __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_227] = { let __args: [G; IN_227] = [__v_6, __v_59]; 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_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_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_60, __v_62]; 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_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_227] = { let __args: [G; IN_227] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+    let __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_200] = { let __args: [G; IN_200] = [__v_65, __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_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_766] = [];
-    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_770] = [];
+    record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_767: usize = 0;
-const IN_767: usize = 0;
-const OUT_767: usize = 0;
-fn aiur_fn_767(
-  inp: [G; IN_767],
+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_767], ExecError> {
+) -> Result<[G; OUT_771], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = []; 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_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_768: usize = 1;
-const IN_768: usize = 1;
-const OUT_768: usize = 0;
-fn aiur_fn_768(
-  inp: [G; IN_768],
+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_768], ExecError> {
+) -> 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_768] = [];
-        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_772] = [];
+        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64343,7 +64443,7 @@ fn aiur_fn_768(
         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_107] = { let __args: [G; IN_107] = [__v_7]; 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_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];
@@ -64393,27 +64493,27 @@ fn aiur_fn_768(
         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_57: G = __loaded[0];
-        let __v_58: G = __loaded[1];
-        let __v_59: G = __loaded[2];
-        let __v_60: G = G::from_u64(1);
-        let __v_61: G = G::from_u64(1);
-        if (__v_57 != __v_60) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
+        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_58 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_61.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_59 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.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 __v_62: G = G::from_u64(1);
-        let __v_63: G = G::from_u64(1);
-        let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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_64]; 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_65: G = __r_arr[0];
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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 __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];
@@ -64446,7 +64546,7 @@ fn aiur_fn_768(
         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_17] = { let __args: [G; IN_17] = [__v_65]; 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_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];
@@ -64575,24 +64675,24 @@ fn aiur_fn_768(
         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_768] = { let __args: [G; IN_768] = [__v_2]; 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 __ret: [G; OUT_768] = [];
-        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_769: usize = 2;
-const IN_769: usize = 2;
-const OUT_769: usize = 1;
-fn aiur_fn_769(
-  inp: [G; IN_769],
+const INPUT_SIZE_773: usize = 2;
+const IN_773: usize = 2;
+const OUT_773: usize = 1;
+fn aiur_fn_773(
+  inp: [G; IN_773],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_769], 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];
@@ -64607,17 +64707,17 @@ fn aiur_fn_769(
         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_769] = [__v_9];
-        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_773] = [__v_9];
+        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_4, __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 __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_769] = [__v_7];
-        record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_773] = [__v_7];
+        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64627,15 +64727,15 @@ fn aiur_fn_769(
   })
 }
 
-const INPUT_SIZE_770: usize = 1;
-const IN_770: usize = 1;
-const OUT_770: usize = 8;
-fn aiur_fn_770(
-  inp: [G; IN_770],
+const INPUT_SIZE_774: usize = 1;
+const IN_774: usize = 1;
+const OUT_774: usize = 8;
+fn aiur_fn_774(
+  inp: [G; IN_774],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_770], ExecError> {
+) -> Result<[G; OUT_774], 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 };
@@ -64659,12 +64759,12 @@ fn aiur_fn_770(
         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_770] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -64673,7 +64773,7 @@ fn aiur_fn_770(
         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_10] = { let __args: [G; IN_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[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_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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -64682,8 +64782,8 @@ fn aiur_fn_770(
         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_770] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -64693,15 +64793,15 @@ fn aiur_fn_770(
   })
 }
 
-const INPUT_SIZE_771: usize = 1;
-const IN_771: usize = 1;
-const OUT_771: usize = 8;
-fn aiur_fn_771(
-  inp: [G; IN_771],
+const INPUT_SIZE_775: usize = 1;
+const IN_775: usize = 1;
+const OUT_775: usize = 8;
+fn aiur_fn_775(
+  inp: [G; IN_775],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_771], ExecError> {
+) -> Result<[G; OUT_775], 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 };
@@ -64718,12 +64818,12 @@ fn aiur_fn_771(
         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_771] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = __r_arr[2];
@@ -64732,7 +64832,7 @@ fn aiur_fn_771(
         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_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 __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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -64741,8 +64841,8 @@ fn aiur_fn_771(
         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_771] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -64752,15 +64852,15 @@ fn aiur_fn_771(
   })
 }
 
-const INPUT_SIZE_772: usize = 2;
-const IN_772: usize = 2;
-const OUT_772: usize = 1;
-fn aiur_fn_772(
-  inp: [G; IN_772],
+const INPUT_SIZE_776: usize = 2;
+const IN_776: usize = 2;
+const OUT_776: usize = 1;
+fn aiur_fn_776(
+  inp: [G; IN_776],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_772], 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];
@@ -64770,17 +64870,17 @@ fn aiur_fn_772(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_772] = [__v_1];
-        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_776] = [__v_1];
+        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __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_772] = [__v_7];
-        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_776] = [__v_7];
+        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64790,15 +64890,15 @@ fn aiur_fn_772(
   })
 }
 
-const INPUT_SIZE_773: usize = 8;
-const IN_773: usize = 8;
-const OUT_773: usize = 1;
-fn aiur_fn_773(
-  inp: [G; IN_773],
+const INPUT_SIZE_777: usize = 8;
+const IN_777: usize = 8;
+const OUT_777: usize = 1;
+fn aiur_fn_777(
+  inp: [G; IN_777],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_773], ExecError> {
+) -> Result<[G; OUT_777], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64810,8 +64910,8 @@ fn aiur_fn_773(
     let __v_7: G = inp[7];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_773] = [__v_7];
-        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_777] = [__v_7];
+        record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -64832,25 +64932,25 @@ fn aiur_fn_773(
         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_773] = { let __args: [G; IN_773] = [__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[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_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 __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_773] = [__v_21];
-            record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_777] = [__v_21];
+            record.function_queries[777].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_773] = [__v_4];
-                record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_777] = [__v_4];
+                record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__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[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_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 __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_773] = [__v_22];
-                record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_777] = [__v_22];
+                record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -64864,15 +64964,15 @@ fn aiur_fn_773(
   })
 }
 
-const INPUT_SIZE_774: usize = 2;
-const IN_774: usize = 2;
-const OUT_774: usize = 1;
-fn aiur_fn_774(
-  inp: [G; IN_774],
+const INPUT_SIZE_778: usize = 2;
+const IN_778: usize = 2;
+const OUT_778: usize = 1;
+fn aiur_fn_778(
+  inp: [G; IN_778],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_774], ExecError> {
+) -> Result<[G; OUT_778], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64884,17 +64984,17 @@ fn aiur_fn_774(
     let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_774] = [__v_1];
-        record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_778] = [__v_1];
+        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_6, __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 __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 __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_774] = [__v_9];
-        record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_778] = [__v_9];
+        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64904,37 +65004,37 @@ fn aiur_fn_774(
   })
 }
 
-const INPUT_SIZE_775: usize = 1;
-const IN_775: usize = 1;
-const OUT_775: usize = 1;
-fn aiur_fn_775(
-  inp: [G; IN_775],
+const INPUT_SIZE_779: usize = 1;
+const IN_779: usize = 1;
+const OUT_779: usize = 1;
+fn aiur_fn_779(
+  inp: [G; IN_779],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_775], ExecError> {
+) -> Result<[G; OUT_779], 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_798] = { let __args: [G; IN_798] = [__v_0, __v_3]; 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_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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_775] = [__v_4];
-    record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_779] = [__v_4];
+    record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_776: usize = 1;
-const IN_776: usize = 1;
-const OUT_776: usize = 8;
-fn aiur_fn_776(
-  inp: [G; IN_776],
+const INPUT_SIZE_780: usize = 1;
+const IN_780: usize = 1;
+const OUT_780: usize = 8;
+fn aiur_fn_780(
+  inp: [G; IN_780],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_776], ExecError> {
+) -> Result<[G; OUT_780], 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 };
@@ -64984,12 +65084,12 @@ fn aiur_fn_776(
         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_776] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
-        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__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_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 __v_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -64998,7 +65098,7 @@ fn aiur_fn_776(
         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_10] = { let __args: [G; IN_10] = [__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[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_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 __v_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -65007,8 +65107,8 @@ fn aiur_fn_776(
         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_776] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
-        record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -65018,19 +65118,19 @@ fn aiur_fn_776(
   })
 }
 
-const INPUT_SIZE_777: usize = 2;
-const IN_777: usize = 2;
-const OUT_777: usize = 1;
-fn aiur_fn_777(
-  inp: [G; IN_777],
+const INPUT_SIZE_781: usize = 2;
+const IN_781: usize = 2;
+const OUT_781: usize = 1;
+fn aiur_fn_781(
+  inp: [G; IN_781],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_777], ExecError> {
+) -> Result<[G; OUT_781], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[795].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_795] = unsafe { *(result.output.as_ptr() as *const [G; OUT_795]) }; __ret } else { aiur_fn_795(__args, record, io_buffer, __cu)? } };
+    let __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 __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];
@@ -65038,8 +65138,8 @@ fn aiur_fn_777(
     let __v_5: G = __loaded[2];
     match __v_3.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_781] = [__v_4];
+        record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65049,15 +65149,15 @@ fn aiur_fn_777(
   })
 }
 
-const INPUT_SIZE_778: usize = 9;
-const IN_778: usize = 9;
-const OUT_778: usize = 1;
-fn aiur_fn_778(
-  inp: [G; IN_778],
+const INPUT_SIZE_782: usize = 9;
+const IN_782: usize = 9;
+const OUT_782: usize = 1;
+fn aiur_fn_782(
+  inp: [G; IN_782],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_778], ExecError> {
+) -> Result<[G; OUT_782], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65078,12 +65178,12 @@ fn aiur_fn_778(
         let __v_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_778] = [__v_10];
-            record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_782] = [__v_10];
+            record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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 __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 __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __v_15: G = __r_arr[2];
@@ -65092,10 +65192,10 @@ fn aiur_fn_778(
             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_778] = { let __args: [G; IN_778] = [__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[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_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 __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_778] = [__v_21];
-            record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_782] = [__v_21];
+            record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65110,15 +65210,15 @@ 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_783: usize = 1;
+const IN_783: usize = 1;
+const OUT_783: usize = 1;
+fn aiur_fn_783(
+  inp: [G; IN_783],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_779], ExecError> {
+) -> Result<[G; OUT_783], 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 };
@@ -65135,17 +65235,17 @@ fn aiur_fn_779(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_779] = [__v_11];
-        record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_783] = [__v_11];
+        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_10]; 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_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 __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_779] = [__v_13];
-        record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_783] = [__v_13];
+        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65155,15 +65255,15 @@ fn aiur_fn_779(
   })
 }
 
-const INPUT_SIZE_780: usize = 7;
-const IN_780: usize = 7;
-const OUT_780: usize = 1;
-fn aiur_fn_780(
-  inp: [G; IN_780],
+const INPUT_SIZE_784: usize = 7;
+const IN_784: usize = 7;
+const OUT_784: usize = 1;
+fn aiur_fn_784(
+  inp: [G; IN_784],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_780], ExecError> {
+) -> Result<[G; OUT_784], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65191,25 +65291,25 @@ fn aiur_fn_780(
         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_780] = { let __args: [G; IN_780] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_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 __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_780] = [__v_20];
-            record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_784] = [__v_20];
+            record.function_queries[784].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_780] = [__v_4];
-                record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_784] = [__v_4];
+                record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_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 __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_780] = [__v_21];
-                record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_784] = [__v_21];
+                record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -65223,15 +65323,15 @@ fn aiur_fn_780(
   })
 }
 
-const INPUT_SIZE_781: usize = 9;
-const IN_781: usize = 9;
-const OUT_781: usize = 45;
-fn aiur_fn_781(
-  inp: [G; IN_781],
+const INPUT_SIZE_785: usize = 9;
+const IN_785: usize = 9;
+const OUT_785: usize = 45;
+fn aiur_fn_785(
+  inp: [G; IN_785],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_781], ExecError> {
+) -> Result<[G; OUT_785], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65296,12 +65396,12 @@ fn aiur_fn_781(
         let __v_56: G = __r_arr[0];
         match __v_56.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_781] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           0u64 => {
-            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 __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 __v_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
             let __v_59: G = __r_arr[2];
@@ -65310,7 +65410,7 @@ fn aiur_fn_781(
             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_781] = { let __args: [G; IN_781] = [__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[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_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 __v_65: G = __r_arr[0];
             let __v_66: G = __r_arr[1];
             let __v_67: G = __r_arr[2];
@@ -65356,8 +65456,8 @@ fn aiur_fn_781(
             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_781] = [__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[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -65372,15 +65472,15 @@ fn aiur_fn_781(
   })
 }
 
-const INPUT_SIZE_782: usize = 2;
-const IN_782: usize = 2;
-const OUT_782: usize = 1;
-fn aiur_fn_782(
-  inp: [G; IN_782],
+const INPUT_SIZE_786: usize = 2;
+const IN_786: usize = 2;
+const OUT_786: usize = 1;
+fn aiur_fn_786(
+  inp: [G; IN_786],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_782], ExecError> {
+) -> Result<[G; OUT_786], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65393,17 +65493,17 @@ fn aiur_fn_782(
     let __v_7: G = __loaded[5];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_782] = [__v_1];
-        record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_786] = [__v_1];
+        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_7, __v_1]; 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_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 __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_782] = [__v_10];
-        record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_786] = [__v_10];
+        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65413,15 +65513,15 @@ fn aiur_fn_782(
   })
 }
 
-const INPUT_SIZE_783: usize = 1;
-const IN_783: usize = 1;
-const OUT_783: usize = 8;
-fn aiur_fn_783(
-  inp: [G; IN_783],
+const INPUT_SIZE_787: usize = 1;
+const IN_787: usize = 1;
+const OUT_787: usize = 8;
+fn aiur_fn_787(
+  inp: [G; IN_787],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_783], ExecError> {
+) -> Result<[G; OUT_787], 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 };
@@ -65482,12 +65582,12 @@ fn aiur_fn_783(
         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_783] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_47]; 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_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 __v_48: G = __r_arr[0];
         let __v_49: G = __r_arr[1];
         let __v_50: G = __r_arr[2];
@@ -65496,7 +65596,7 @@ fn aiur_fn_783(
         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_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 __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 __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -65505,8 +65605,8 @@ fn aiur_fn_783(
         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_783] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -65516,15 +65616,15 @@ fn aiur_fn_783(
   })
 }
 
-const INPUT_SIZE_784: usize = 8;
-const IN_784: usize = 8;
-const OUT_784: usize = 6;
-fn aiur_fn_784(
-  inp: [G; IN_784],
+const INPUT_SIZE_788: usize = 8;
+const IN_788: usize = 8;
+const OUT_788: usize = 6;
+fn aiur_fn_788(
+  inp: [G; IN_788],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_784], ExecError> {
+) -> Result<[G; OUT_788], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65534,7 +65634,7 @@ fn aiur_fn_784(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__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[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_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 __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
@@ -65545,8 +65645,8 @@ fn aiur_fn_784(
       0u64 => {
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(1);
-        let __ret: [G; OUT_784] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
-        record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -65556,15 +65656,15 @@ fn aiur_fn_784(
   })
 }
 
-const INPUT_SIZE_785: usize = 1;
-const IN_785: usize = 1;
-const OUT_785: usize = 8;
-fn aiur_fn_785(
-  inp: [G; IN_785],
+const INPUT_SIZE_789: usize = 1;
+const IN_789: usize = 1;
+const OUT_789: usize = 8;
+fn aiur_fn_789(
+  inp: [G; IN_789],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_785], ExecError> {
+) -> Result<[G; OUT_789], 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 };
@@ -65589,12 +65689,12 @@ fn aiur_fn_785(
         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_785] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_11]; 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_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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -65603,7 +65703,7 @@ fn aiur_fn_785(
         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_10] = { let __args: [G; IN_10] = [__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[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_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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -65612,8 +65712,8 @@ fn aiur_fn_785(
         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_785] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
-        record.function_queries[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       _ => {
@@ -65623,15 +65723,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_790: usize = 2;
+const IN_790: usize = 2;
+const OUT_790: usize = 1;
+fn aiur_fn_790(
+  inp: [G; IN_790],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_786], ExecError> {
+) -> Result<[G; OUT_790], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65642,17 +65742,17 @@ fn aiur_fn_786(
     let __v_5: G = __loaded[3];
     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_790] = [__v_1];
+        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_5, __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_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 __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_786] = [__v_8];
-        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_790] = [__v_8];
+        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65662,15 +65762,15 @@ fn aiur_fn_786(
   })
 }
 
-const INPUT_SIZE_787: usize = 9;
-const IN_787: usize = 9;
-const OUT_787: usize = 34;
-fn aiur_fn_787(
-  inp: [G; IN_787],
+const INPUT_SIZE_791: usize = 9;
+const IN_791: usize = 9;
+const OUT_791: usize = 34;
+fn aiur_fn_791(
+  inp: [G; IN_791],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_787], ExecError> {
+) -> Result<[G; OUT_791], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65724,12 +65824,12 @@ fn aiur_fn_787(
         let __v_45: G = __r_arr[0];
         match __v_45.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_787] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           0u64 => {
-            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 __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 __v_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
             let __v_48: G = __r_arr[2];
@@ -65738,7 +65838,7 @@ fn aiur_fn_787(
             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_787] = { let __args: [G; IN_787] = [__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[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_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 __v_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
             let __v_56: G = __r_arr[2];
@@ -65773,8 +65873,8 @@ fn aiur_fn_787(
             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_787] = [__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[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -65789,15 +65889,15 @@ fn aiur_fn_787(
   })
 }
 
-const INPUT_SIZE_788: usize = 1;
-const IN_788: usize = 1;
-const OUT_788: usize = 1;
-fn aiur_fn_788(
-  inp: [G; IN_788],
+const INPUT_SIZE_792: usize = 1;
+const IN_792: usize = 1;
+const OUT_792: usize = 1;
+fn aiur_fn_792(
+  inp: [G; IN_792],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_788], ExecError> {
+) -> Result<[G; OUT_792], 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 };
@@ -65807,14 +65907,14 @@ fn aiur_fn_788(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_788] = [__v_4];
-        record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_792] = [__v_4];
+        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_788] = [__v_4];
-        record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_792] = [__v_4];
+        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65824,19 +65924,19 @@ fn aiur_fn_788(
   })
 }
 
-const INPUT_SIZE_789: usize = 2;
-const IN_789: usize = 2;
-const OUT_789: usize = 3;
-fn aiur_fn_789(
-  inp: [G; IN_789],
+const INPUT_SIZE_793: usize = 2;
+const IN_793: usize = 2;
+const OUT_793: usize = 3;
+fn aiur_fn_793(
+  inp: [G; IN_793],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_789], ExecError> {
+) -> Result<[G; OUT_793], 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_800] = { let __args: [G; IN_800] = [__v_0, __v_1]; 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_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 __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];
@@ -65846,8 +65946,8 @@ fn aiur_fn_789(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_789] = [__v_4, __v_5, __v_6];
-        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_793] = [__v_4, __v_5, __v_6];
+        record.function_queries[793].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65857,28 +65957,28 @@ 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_794: usize = 2;
+const IN_794: usize = 2;
+const OUT_794: usize = 1;
+fn aiur_fn_794(
+  inp: [G; IN_794],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_790], ExecError> {
+) -> Result<[G; OUT_794], 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_790] = [__v_0];
-        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_794] = [__v_0];
+        record.function_queries[794].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_790] = { let __args: [G; IN_790] = [__v_0, __v_3]; 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_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 __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];
@@ -65889,8 +65989,8 @@ fn aiur_fn_790(
         let __v_10: G = __loaded[5];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_790] = [__v_10];
-            record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_794] = [__v_10];
+            record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65902,15 +66002,15 @@ fn aiur_fn_790(
   })
 }
 
-const INPUT_SIZE_791: usize = 2;
-const IN_791: usize = 2;
-const OUT_791: usize = 1;
-fn aiur_fn_791(
-  inp: [G; IN_791],
+const INPUT_SIZE_795: usize = 2;
+const IN_795: usize = 2;
+const OUT_795: usize = 1;
+fn aiur_fn_795(
+  inp: [G; IN_795],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_791], ExecError> {
+) -> Result<[G; OUT_795], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65919,8 +66019,8 @@ fn aiur_fn_791(
         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_791] = [__v_4];
-        record.function_queries[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_795] = [__v_4];
+        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65933,11 +66033,11 @@ fn aiur_fn_791(
             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_791] = { let __args: [G; IN_791] = [__v_4, __v_7]; 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_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 __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_791] = [__v_9];
-            record.function_queries[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_795] = [__v_9];
+            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65949,15 +66049,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_796: usize = 1;
+const IN_796: usize = 1;
+const OUT_796: usize = 1;
+fn aiur_fn_796(
+  inp: [G; IN_796],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_792], ExecError> {
+) -> Result<[G; OUT_796], 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 };
@@ -66000,17 +66100,17 @@ fn aiur_fn_792(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_792] = [__v_37];
-        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_796] = [__v_37];
+        record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_36]; 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_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 __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_792] = [__v_39];
-        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_796] = [__v_39];
+        record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66020,15 +66120,15 @@ fn aiur_fn_792(
   })
 }
 
-const INPUT_SIZE_793: usize = 1;
-const IN_793: usize = 1;
-const OUT_793: usize = 1;
-fn aiur_fn_793(
-  inp: [G; IN_793],
+const INPUT_SIZE_797: usize = 1;
+const IN_797: usize = 1;
+const OUT_797: usize = 1;
+fn aiur_fn_797(
+  inp: [G; IN_797],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_793], ExecError> {
+) -> Result<[G; OUT_797], 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 };
@@ -66041,17 +66141,17 @@ fn aiur_fn_793(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_793] = [__v_7];
-        record.function_queries[793].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_797] = [__v_7];
+        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_6]; 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_797] = { let __args: [G; IN_797] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[797].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_797] = unsafe { *(result.output.as_ptr() as *const [G; OUT_797]) }; __ret } else { aiur_fn_797(__args, record, io_buffer, __cu)? } };
         let __v_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_793] = [__v_9];
-        record.function_queries[793].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_797] = [__v_9];
+        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66061,15 +66161,15 @@ 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_798: usize = 2;
+const IN_798: usize = 2;
+const OUT_798: usize = 1;
+fn aiur_fn_798(
+  inp: [G; IN_798],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_794], ExecError> {
+) -> Result<[G; OUT_798], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66078,8 +66178,8 @@ fn aiur_fn_794(
         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_794] = [__v_4];
-        record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_798] = [__v_4];
+        record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66095,11 +66195,11 @@ fn aiur_fn_794(
             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_794] = { let __args: [G; IN_794] = [__v_7, __v_10]; 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_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 __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_794] = [__v_12];
-            record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_798] = [__v_12];
+            record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66111,28 +66211,28 @@ 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_799: usize = 2;
+const IN_799: usize = 2;
+const OUT_799: usize = 1;
+fn aiur_fn_799(
+  inp: [G; IN_799],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_795], ExecError> {
+) -> Result<[G; OUT_799], 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_795] = [__v_0];
-        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_799] = [__v_0];
+        record.function_queries[799].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_795] = { let __args: [G; IN_795] = [__v_0, __v_3]; 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_799] = { let __args: [G; IN_799] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[799].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_799] = unsafe { *(result.output.as_ptr() as *const [G; OUT_799]) }; __ret } else { aiur_fn_799(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __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];
@@ -66140,8 +66240,8 @@ fn aiur_fn_795(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_795] = [__v_7];
-            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_799] = [__v_7];
+            record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66153,15 +66253,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_800: usize = 1;
+const IN_800: usize = 1;
+const OUT_800: usize = 1;
+fn aiur_fn_800(
+  inp: [G; IN_800],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_796], ExecError> {
+) -> Result<[G; OUT_800], 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 };
@@ -66173,17 +66273,17 @@ fn aiur_fn_796(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_796] = [__v_6];
-        record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_800] = [__v_6];
+        record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_5]; 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_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 __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_796] = [__v_8];
-        record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_800] = [__v_8];
+        record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66193,15 +66293,15 @@ fn aiur_fn_796(
   })
 }
 
-const INPUT_SIZE_797: usize = 9;
-const IN_797: usize = 9;
-const OUT_797: usize = 1;
-fn aiur_fn_797(
-  inp: [G; IN_797],
+const INPUT_SIZE_801: usize = 9;
+const IN_801: usize = 9;
+const OUT_801: usize = 1;
+fn aiur_fn_801(
+  inp: [G; IN_801],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_797], ExecError> {
+) -> Result<[G; OUT_801], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66230,17 +66330,17 @@ fn aiur_fn_797(
         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_797] = [__v_23];
-        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_801] = [__v_23];
+        record.function_queries[801].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__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[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_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 __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_797] = [__v_21];
-        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_801] = [__v_21];
+        record.function_queries[801].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66250,15 +66350,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_802: usize = 2;
+const IN_802: usize = 2;
+const OUT_802: usize = 1;
+fn aiur_fn_802(
+  inp: [G; IN_802],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_798], ExecError> {
+) -> Result<[G; OUT_802], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66268,17 +66368,17 @@ fn aiur_fn_798(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_798] = [__v_1];
-        record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_802] = [__v_1];
+        record.function_queries[802].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_798] = { let __args: [G; IN_798] = [__v_4, __v_6]; 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_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 __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_798] = [__v_7];
-        record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_802] = [__v_7];
+        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66288,15 +66388,15 @@ fn aiur_fn_798(
   })
 }
 
-const INPUT_SIZE_799: usize = 8;
-const IN_799: usize = 8;
-const OUT_799: usize = 6;
-fn aiur_fn_799(
-  inp: [G; IN_799],
+const INPUT_SIZE_803: usize = 8;
+const IN_803: usize = 8;
+const OUT_803: usize = 6;
+fn aiur_fn_803(
+  inp: [G; IN_803],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_799], ExecError> {
+) -> Result<[G; OUT_803], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66316,8 +66416,8 @@ fn aiur_fn_799(
         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_799] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
-        record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
       0u64 => {
@@ -66338,22 +66438,22 @@ fn aiur_fn_799(
         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_799] = { let __args: [G; IN_799] = [__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[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_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 __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_801] = { let __args: [G; IN_801] = [__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[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_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 __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_799] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-            record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
           _ => {
@@ -66363,27 +66463,27 @@ fn aiur_fn_799(
                 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_799] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
-                record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_799] = { let __args: [G; IN_799] = [__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[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_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 __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_801] = { let __args: [G; IN_801] = [__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[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_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 __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_799] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -66397,28 +66497,28 @@ fn aiur_fn_799(
   })
 }
 
-const INPUT_SIZE_800: usize = 2;
-const IN_800: usize = 2;
-const OUT_800: usize = 1;
-fn aiur_fn_800(
-  inp: [G; IN_800],
+const INPUT_SIZE_804: usize = 2;
+const IN_804: usize = 2;
+const OUT_804: usize = 1;
+fn aiur_fn_804(
+  inp: [G; IN_804],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_800], ExecError> {
+) -> Result<[G; OUT_804], 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_800] = [__v_0];
-        record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_804] = [__v_0];
+        record.function_queries[804].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_800] = { let __args: [G; IN_800] = [__v_0, __v_3]; 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_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 __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];
@@ -66428,8 +66528,8 @@ fn aiur_fn_800(
         let __v_9: G = __loaded[4];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_800] = [__v_9];
-            record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_804] = [__v_9];
+            record.function_queries[804].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66441,15 +66541,15 @@ fn aiur_fn_800(
   })
 }
 
-const INPUT_SIZE_801: usize = 15;
-const IN_801: usize = 15;
-const OUT_801: usize = 6;
-fn aiur_fn_801(
-  inp: [G; IN_801],
+const INPUT_SIZE_805: usize = 15;
+const IN_805: usize = 15;
+const OUT_805: usize = 6;
+fn aiur_fn_805(
+  inp: [G; IN_805],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_801], ExecError> {
+) -> Result<[G; OUT_805], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66468,38 +66568,38 @@ fn aiur_fn_801(
     let __v_14: G = inp[14];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_1, __v_2, __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[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_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 __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_801] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
-        record.function_queries[801].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         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_801] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
-        record.function_queries[801].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_802: usize = 14;
-const IN_802: usize = 14;
-const OUT_802: usize = 6;
-fn aiur_fn_802(
-  inp: [G; IN_802],
+const INPUT_SIZE_806: usize = 14;
+const IN_806: usize = 14;
+const OUT_806: usize = 6;
+fn aiur_fn_806(
+  inp: [G; IN_806],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_802], ExecError> {
+) -> Result<[G; OUT_806], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66539,8 +66639,8 @@ fn aiur_fn_802(
                     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_802] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
-                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                   _ => {
@@ -66564,8 +66664,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                           _ => {
@@ -66593,8 +66693,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66618,8 +66718,8 @@ fn aiur_fn_802(
                                                     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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    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));
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -66627,8 +66727,8 @@ fn aiur_fn_802(
                                                     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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    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));
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -66638,8 +66738,8 @@ fn aiur_fn_802(
                                                 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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66667,8 +66767,8 @@ fn aiur_fn_802(
                                                 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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66676,8 +66776,8 @@ fn aiur_fn_802(
                                                 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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66687,8 +66787,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66700,8 +66800,8 @@ fn aiur_fn_802(
                                     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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                 }
@@ -66711,8 +66811,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -66744,8 +66844,8 @@ fn aiur_fn_802(
                                         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_802] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66769,8 +66869,8 @@ fn aiur_fn_802(
                                                 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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66778,8 +66878,8 @@ fn aiur_fn_802(
                                                 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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66789,8 +66889,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66818,8 +66918,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66827,8 +66927,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66838,8 +66938,8 @@ fn aiur_fn_802(
                                         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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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));
                                         return Ok(__ret);
                                       },
                                     }
@@ -66851,8 +66951,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -66862,8 +66962,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -66893,8 +66993,8 @@ fn aiur_fn_802(
                         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_802] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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));
                         return Ok(__ret);
                       },
                       _ => {
@@ -66922,8 +67022,8 @@ fn aiur_fn_802(
                                         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_802] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66947,8 +67047,8 @@ fn aiur_fn_802(
                                                 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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66956,8 +67056,8 @@ fn aiur_fn_802(
                                                 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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                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));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66967,8 +67067,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66996,8 +67096,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -67005,8 +67105,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                         }
@@ -67016,8 +67116,8 @@ fn aiur_fn_802(
                                         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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67029,8 +67129,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -67040,8 +67140,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -67073,8 +67173,8 @@ fn aiur_fn_802(
                                     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_802] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67098,8 +67198,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -67107,8 +67207,8 @@ fn aiur_fn_802(
                                             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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            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));
                                             return Ok(__ret);
                                           },
                                         }
@@ -67118,8 +67218,8 @@ fn aiur_fn_802(
                                         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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67147,8 +67247,8 @@ fn aiur_fn_802(
                                         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_802] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -67156,8 +67256,8 @@ fn aiur_fn_802(
                                         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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        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));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67167,8 +67267,8 @@ fn aiur_fn_802(
                                     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_802] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67180,8 +67280,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -67191,8 +67291,8 @@ fn aiur_fn_802(
                         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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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));
                         return Ok(__ret);
                       },
                     }
@@ -67226,8 +67326,8 @@ fn aiur_fn_802(
                             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_802] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67251,8 +67351,8 @@ fn aiur_fn_802(
                                     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_802] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67260,8 +67360,8 @@ fn aiur_fn_802(
                                     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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67271,8 +67371,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -67300,8 +67400,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67309,8 +67409,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -67320,8 +67420,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -67333,8 +67433,8 @@ fn aiur_fn_802(
                     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_802] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                    record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    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));
                     return Ok(__ret);
                   },
                 }
@@ -67344,8 +67444,8 @@ fn aiur_fn_802(
                 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_802] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -67377,8 +67477,8 @@ fn aiur_fn_802(
                         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_802] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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));
                         return Ok(__ret);
                       },
                       _ => {
@@ -67402,8 +67502,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67411,8 +67511,8 @@ fn aiur_fn_802(
                                 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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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));
                                 return Ok(__ret);
                               },
                             }
@@ -67422,8 +67522,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -67451,8 +67551,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67460,8 +67560,8 @@ fn aiur_fn_802(
                             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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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));
                             return Ok(__ret);
                           },
                         }
@@ -67471,8 +67571,8 @@ fn aiur_fn_802(
                         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_802] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        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));
                         return Ok(__ret);
                       },
                     }
@@ -67484,8 +67584,8 @@ fn aiur_fn_802(
                 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_802] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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));
                 return Ok(__ret);
               },
             }
@@ -67495,8 +67595,8 @@ fn aiur_fn_802(
             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_802] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-            record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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));
             return Ok(__ret);
           },
         }
@@ -71527,6 +71627,26 @@ pub(crate) fn execute_generated(
       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));
     },